cachesize

OPTIONS WHICH AFFECT THE CACHE SIZE

Tags under this section deals with cache memory configurations like cache memory size, swap size, maximum and minimum object size, cache and memory replacement policies.

cache_mem

cache_swap_low

cache_swap_high

maximum_object_size

minimum_object_size

maximum_object_size_in_memory

ipcache_size

ipcache_low

ipcache_high

fqdncache_size

cache_replacement_policy

memory_replacement_policy

max_stale

Description

cache_mem defines the ideal amount of memory to be used for In-Transit objects, Hot Objects, Negative-Cached
objects

Build Option

Default

Usage

cache_mem size

Default

cache_mem 8 MB

Synopsis

Data for these objects are stored in 4 KB blocks. This parameter specifies the ideal upper limit on the total size of 4 KB blocks allocated.

In-transit objects have priority over the others. When additional space is needed for incoming data, Negative-cached and Hot objects will be released. In other words, the negative-cached and hot objects will fill up any unused space not needed for In-transit objects.

If circumstances require, this limit will be exceeded. Specifically, if your incoming request rate requires more than cache_mem of memory to hold In-transit objects, Squid will exceed this limit to satisfy the new requests. When the load decreases, blocks will be freed until the high-water mark is reached. Thereafter, blocks will be used to store hot objects.

Note
This tag does not specify the maximum process size. It places a limit on one aspect of squid's memory usage. Squid uses memory for other things as well. Process will probably become twice or three times bigger than the value put here.

Arguments

Example(s)
cache_mem 32 MB

Description

This defines low- and high-water marks for cache object replacements

Build Option

Default

Usage

cache_swap_low percent( 0-100 )
cache_swap_high percent( 0-100 )

Default

cache_swap_low 90
cache_swap_high 95

Synopsis

This tags define when the replacement should take place. Replacement begins when the swap (disk) usage is above the low-water mark and attempts to maintain utilization near the low-water mark. As swap utilization gets close to high-water mark object eviction becomes more aggressive. If utilization is close to the low-water mark less replacement is done each time.

Defaults are 90% and 95%. If you have a large cache, 5% could be hundreds of MB. If this is the case you may wish to set these numbers closer together.

Arguments

Example(s)
cache_swap_low 50
cache_swap_high 75

Description

Defines maximum size for objects to be stored in the disk

Build Option

Default

Usage

maximum_object_size size

Default

object_size 4096 KB

Synopsis

Objects larger than this size will NOT be saved on disk. The value is specified in kilobytes, and the default is 4MB. If you wish to get a high BYTES hit ratio, you should probably increase this (one 32 MB object hit counts for 3200 10KB hits). Leave this value low if you wish to increase the speed more than what you want to save bandwidth.

Note
If using the LFUDA replacement policy you should increase this value to maximize the byte hit rate improvement of LFUDA! See replacement_policy below for a discussion of this policy.

Arguments

Example(s)
maximum_object_size 320010 KB

Description

Specifies the minimum object size below which will not be saved to the disk

Build Option

Default

Usage

minimum_object_size size

Default

minimum_object_size 0 KB

Synopsis
Objects smaller than this size will NOT be saved on disk. The value is specified in kilobytes, and the default is 0 KB, which means there is no minimum.

Arguments

Example(s)
minimum_object_size 10 KB

Description

Defines maximum size of the object to be kept in memory cache

Build Option

Default

Usage

maximum_object_size_in_memory size

Default

maximum_object_size_in_memory 8 KB

Synopsis

Objects greater than the size specified in this tag will not be kept in the memory cache. This should be set high enough to keep objects accessed frequently in memory to improve performance at the same time low enough to keep larger objects from hoarding cache_mem.

Arguments

Example(s)
maximum_object_size_in_memory 100 KB

Description

The size of the cache used for IP addresses and the high and low water marks for the same

Build Option

Default

Usage

ipcache_size number of entries
ipcache_low percent
ipcache_high percent

Default

ipcache_size 1024
ipcache_low 90
ipcache_high 95

Synopsis
Defines the size of cache needed for caching ip address, also its low and high water marks.

Arguments

Example(s)
ipcache_size 2048
ipcache_low 90
ipcache_high 95

Description

Defines the size of in memory cache needed for fully qualified domain names

Build Option

Default

Usage

fqdncache_size number of entries

Default

fqdncache_size 1024

Synopsis

This is used to specify maximum number of entries for fully qualified domain names. Defaults to 1024, which is usually a safe value. In environments where DNS queries are slow, raising this may help.

Arguments

Example(s)
fqdncache_size 2048

Description

The cache replacement policy parameter determines which objects are to be replaced when disk space is needed

Build Option

--enable-removal-policy

Usage

cache_replacement_policy policy

Default

cache_replacement_policy lru

Synopsis
Whenever space for new objects were not found in the disk, cache_replacement_policy tag determines which objects in the cache memory (disk) should be replaced.

The cache replacement policies is of four types. They are,

This applies to any cache_dir lines listed below this.

The lru policies keeps recently referenced objects.

The heap GDSF policy optimizes object hit rate by keeping smaller popular objects in cache so it has a better chance of getting a hit. It achieves a lower byte hit rate than LFUDA though since it evicts larger (possibly popular) objects.

The heap LFUDA policy keeps popular objects in cache regardless of their size and thus optimizes byte hit rate at the expense of hit rate since one large, popular object will prevent many smaller, slightly less popular objects from being cached.

Both policies utilize a dynamic aging mechanism that prevents cache pollution that can otherwise occur with frequency-based replacement policies.

For more information about the GDSF and LFUDA cache replacement policies see https://www.hpl.hp.com/techreports/1999/HPL-1999-69.html and https://fog.hpl.external.hp.com/techreports/98/HPL-98-173.html.

Note

If using the LFUDA replacement policy you should increase the value of maximum_object_size above its default of 4096 KB to maximize the potential byte hit rate improvement of LFUDA.

Arguments

Example(s)
cache_replacement_policy heap LFUDA

Description

Specifies the policy for object replacement in memory when space for new objects is not available

Build Option

Default

Usage

memory_replacement_policy policy

Default

memory_replacement_policy lru

Synopsis
Like cache_replacement_policy, this applies to memory space (RAM) for object replacement when the required space is not available for new objects.

Policies are same as cache_replacemen_policy.

Arguments

Example(s)
memory_replacement_policy LFUDA

Description

Specify the amount of time how stale content is served by the squid if cache validation fails.

Build Option

Default

Usage

max_stale time_units

Default

max_stale 1 week

Synopsis
This option puts an upper limit on how stale content Squid will serve from the cache if cache validation fails.

Example(s)
max_stale 3 week