reference.conf

####################################
#   Cache Simulator Config File    #
####################################

# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.

caffeine.simulator {

  actor {
    # The number of messages to buffer per actor
    mailbox-size = 10

    # The number of events to send per actor message
    batch-size = 1000
  }

  report {
    # Formats: table, csv
    format = table

    # Columns: policy, hit rate, hits, misses, evictions, admit rate, steps, time
    sort-by = policy
    ascending = true

    # The output destination, either the console or a file path
    output = console
  }

  # The seed for randomized operations
  random-seed = 1033096058

  # The maximum number of entries in the cache
  maximum-size = 512

  policies = [
    # Policies that provide an optimal upper bound
    opt.Unbounded,
    opt.Clairvoyant,

    # Policies based on maintaining a linked-list cross-cutting the hash table
    linked.Lru,
    linked.Mru,
    linked.Lfu,
    linked.Mfu,
    linked.Fifo,
    linked.Clock,
    linked.S4Lru,
    linked.Sieve,
    linked.MultiQueue,
    linked.SegmentedLru,

    # Policies based on obtaining a random sampling from the hash table
    sampled.Lru,
    sampled.Mru,
    sampled.Lfu,
    sampled.Mfu,
    sampled.Fifo,
    sampled.Random,
    sampled.Hyperbolic,

    # Policies based on the Greedy-Dual algorithm
    greedy-dual.Camp,
    greedy-dual.Gdsf,
    greedy-dual.GDWheel,

    # Policies based on the 2Q algorithm
    two-queue.TwoQueue,
    two-queue.TuQueue,
    two-queue.S3Fifo,

    # Policies based on a sketch algorithm
    sketch.WindowTinyLfu,
    sketch.S4WindowTinyLfu,
    sketch.LruWindowTinyLfu,
    sketch.RandomWindowTinyLfu,
    sketch.FullySegmentedWindowTinyLfu,

    sketch.HillClimberWindowTinyLfu,

    sketch.FeedbackTinyLfu,
    sketch.FeedbackWindowTinyLfu,

    sketch.TinyCache,
    sketch.TinyCache_GhostCache,
    sketch.WindowTinyCache,

    # Policies based on the LIRS algorithm
    irr.Frd,
    irr.Lirs,
    irr.DClock,
    irr.ClockPro,
    irr.ClockProPlus,
    irr.ClockProSimple,

    # Policies based on the ARC algorithm
    adaptive.Arc,
    adaptive.Car,
    adaptive.Cart,

    # Caching products
    product.Guava,
    product.TCache,
    product.Cache2k,
    product.Caffeine,
    product.Ehcache3,
    product.Coherence,
    product.Hazelcast,
    product.ExpiringMap,
  ]

  # The admission policy (opposite of eviction policy)
  admission = [
    Always,
    TinyLfu,
  ]

  # The membership filter
  membership {
    # caffeine, guava, fast-filter
    filter = caffeine
    # The false positive probability
    fpp = 0.01
    # The multiple of the maximum size indicating the expected number of insertions
    expected-insertions-multiplier = 3.0

    fast-filter {
      # bloom, counting-bloom, succinct-counting-bloom, blocked-bloom, blocked-bloom-v2
      # succinct-counting-blocked-bloom, succinct-counting-blocked-bloom-v2,
      # succinct-counting-blocked-bloom-ranked-v2,
      type = blocked-bloom
      # The number of bits per key
      bits-per-key = 11
    }
  }

  sampled {
    # The random sample size
    size = 8

    # guess: Chooses items at random until the sample size is reached
    # shuffle: http://en.wikipedia.org/wiki/Fisher–Yates_shuffle
    # reservoir: http://en.wikipedia.org/wiki/Reservoir_sampling
    strategy = guess
  }

  multi-queue {
    # The logical time that an entry can reside idle in a queue before being demoted
    lifetime = 75
    # The number of queues using a 2^n frequency distribution
    num-queues = 8
    # The percentage for the OUT queue
    percent-out = 0.50
  }

  segmented-lru {
    # The percentage for the PROTECTED queue
    percent-protected = 0.80
  }

  s4lru {
    # The number of segments
    levels = 4
  }

  two-queue {
    # The percentage for the IN queue
    percent-in = 0.20
    # The percentage for the OUT queue
    percent-out = 0.50
  }

  tu-queue {
    # The percentage for the HOT queue
    percent-hot = 0.33
    # The percentage for the WARM queue
    percent-warm = 0.33
  }

  s3fifo {
    # The percentage for the S queue
    percent-small = 0.10
    # The percentage for the G queue
    percent-ghost = 0.90
    # The promotion frequency threshold
    move-to-main-threshold = 1
    # The n-bit clock frequency for the S and M queues
    maximum-frequency = 3
  }

  tiny-lfu {
    # CountMinSketch: count-min-4 (4-bit), count-min-64 (64-bit)
    # Table: random-table, tiny-table, perfect-table
    sketch = count-min-4

    # If increments are conservative by only updating the minimum counters for CountMin sketches
    count-min.conservative = false

    jitter {
      # When enabled an otherwise rejected candidate has a random chance of being admitted
      enabled = true
      # The threshold frequency of a warm candidate to give it a random admission
      threshold = 6
      # The admission probability
      probability = 0.0078125
    }

    count-min-64 {
      eps = 0.0001
      confidence = 0.99
    }

    count-min-4 {
      # periodic: Resets by periodically halving all counters
      # incremental: Resets by halving counters in an incremental sweep
      # climber or indicator: Resets periodically at an adaptive interval
      reset = periodic
      # The multiple of the maximum size determining the number of counters
      counters-multiplier = 1.0

      incremental {
        # The incremental reset interval (the number of additions before halving counters)
        interval = 16
      }

      periodic.doorkeeper {
        # When enabled the "counters-multiplier" should be reduced to determine the space savings
        enabled = false
      }
    }
  }

  feedback-tiny-lfu {
    # The maximum emphasis to give newly inserted entries
    maximum-insertion-gain = 5
    # The maximum size of the sample period
    maximum-sample-size = 256
    # The false positive probability of the adaptive filter
    adaptive-fpp = 0.03
  }

  window-tiny-lfu {
    # The percentage for the MAIN space (PROBATION + PROTECTED)
    percent-main = [0.99]
    # The percentage for the PROTECTED MAIN queue
    percent-main-protected = 0.80
  }

  lru-window-tiny-lfu {
    # The percentage for the MAIN queue
    percent-main = [0.99]
  }

  random-window-tiny-lfu {
    # The percentage for the MAIN space
    percent-main = [0.99]
  }

  fully-segmented-window-tiny-lfu {
    # The percentage for the MAIN space (PROBATION + PROTECTED)
    percent-main = [0.99]
    # The percentage for the PROTECTED MAIN queue
    percent-main-protected = 0.80
    # The percentage for the PROTECTED WINDOW queue
    percent-window-protected = 0.80
  }

  s4-window-tiny-lfu {
    # The percentage for the MAIN queue
    percent-main = [0.99]
    # The number of segments in the MAIN space
    levels = 4
  }

  feedback-window-tiny-lfu {
    # The initial percentage for the MAIN space (PROBATION + PROTECTED)
    percent-main = [0.99]
    # The initial percentage for the PROTECTED MAIN queue
    percent-main-protected = 0.80
    # The initial percentage of the WINDOW space that can be pivoted
    percent-pivot = 0.0
    # The amount to increase the window when adapting
    pivot-increment = 8
    # The amount to decrease the window when adapting
    pivot-decrement = 4
    # The maximum size of the WINDOW space
    maximum-window-size = 256
    # The maximum size of the sample period
    maximum-sample-size = 1024
    # The false positive probability of the adaptive filter
    adaptive-fpp = 0.03
  }

  hill-climber-window-tiny-lfu {
    # The initial percentage for the MAIN space (PROBATION + PROTECTED)
    percent-main = [0.99]
    # The initial percentage for the PROTECTED MAIN queue
    percent-main-protected = 0.80

    # simple: Moves a fixed amount based on if the current direction had a positive impact
    # simulated-annealing: A simple hill climber that cools off, reducing the step size
    # stochastic-gradient-descent: Uses the gradient and momentum to walk the curve
    # adam, nadam, amsgrad: SGD with adaptive step sizes
    # indicator: Computes the best configuration based on a sampled skew
    # minisim: Simulates multiple configurations and chooses the best one
    strategy = [
      simple,
      indicator,
    ]

    simple {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.0625
      # The size of the sample period (1.0 = 100%)
      percent-sample = 10.0
      # The difference in hit rate percentage to tolerate before changing directions
      tolerance = 0.0
      # The rate to decrease the step size to adapt by
      step-decay-rate = 0.98
      # The rate to decrease the sampling period
      sample-decay-rate = 1.0
      # The difference in hit rate percentage to tolerate before restarting the adaption
      restart-threshold = 0.05
    }

    simulated-annealing {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.0625
      # The size of the sample period (1.0 = 100%)
      percent-sample = 10.0
      # The difference in hit rate to tolerate before cooling down
      cool-down-tolerance = 0.0
      # The cool down rate
      cool-down-rate = 0.9
      # The minimum temperature, at which point annealing halts
      min-temperature = 0.00001
      # The difference in hit rate to tolerate before restarting
      restart-tolerance = 0.03
      # The chance for a random restart
      random-restart = 0.01
    }

    stochastic-gradient-descent {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.005
      # The size of the sample period (1.0 = 100%)
      percent-sample = 0.05
      # none, momentum, nesterov
      acceleration = momentum
      # The force of acceleration
      beta = 0.9
    }

    adam {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.005
      # The size of the sample period (1.0 = 100%)
      percent-sample = 0.05
      # The decay rate of the momentum
      beta1 = 0.9
      # The decay rate of the velocity
      beta2 = 0.999
      # The fuzz factor for stability
      epsilon = 1e-8
    }

    nadam {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.005
      # The size of the sample period (1.0 = 100%)
      percent-sample = 0.05
      # The decay rate of the momentum
      beta1 = 0.9
      # The decay rate of the velocity
      beta2 = 0.999
      # The fuzz factor for stability
      epsilon = 1e-8
    }

    amsgrad {
      # The percent of the total size to adapt the window by
      percent-pivot = 0.005
      # The size of the sample period (1.0 = 100%)
      percent-sample = 0.05
      # The decay rate of the momentum
      beta1 = 0.9
      # The decay rate of the velocity
      beta2 = 0.999
      # The fuzz factor for stability
      epsilon = 1e-8
    }

    minisim {
      # The period length of the minisim adaptation
      period = 1000000
    }
  }

  indicator {
    # Skew estimation is based on the top-k items
    k = 70
    # The size of the stream summary sketch
    ss-size = 1000
  }

  frd {
    # The percentage for the MAIN queue
    percent-main = 0.90

    # The period length of the indicator adaptation
    period = 50000
  }

  lirs {
    # The percentage for the HOT queue
    percent-hot = 0.99
    # The multiple of the maximum size dedicated to non-resident entries
    non-resident-multiplier = 2.0
  }

  clockpro {
    # The percentage for the minimum resident cold entries
    percent-min-resident-cold = 0.01
    # The percentage for the maximum resident cold entries
    percent-max-resident-cold = 0.99
    # The lower bound for the number of resident cold entries
    lower-bound-resident-cold = 2
    # The multiple of the maximum size dedicated to non-resident entries
    non-resident-multiplier = 2.0
  }

  clockproplus {
    # The percentage for the minimum resident cold entries
    percent-min-resident-cold = 0.01
    # The percentage for the maximum resident cold entries
    percent-max-resident-cold = 0.5
    # The lower bound for the number of resident cold entries
    lower-bound-resident-cold = 2
    # The multiple of the maximum size dedicated to non-resident entries
    non-resident-multiplier = 1.0
  }

  dclock {
    # The percentage for the ACTIVE queue
    percent-active = [ 0.5, 0.99 ]
  }

  coherence {
    # Policies: Hybrid, Lfu, Lru
    policy = [ hybrid, lfu, lru ]
  }

  hazelcast {
    # Policies: Random, Lru, Lfu
    policy = [ random, lru, lfu ]
  }

  expiring-map {
    # Policies: Fifo, Lru
    policy = [ lru ]
  }

  tcache {
    # Policies: Lru, Lfu
    policy = [ lru, lfu ]
  }

  gd-wheel {
    # The number of wheels used in the policy
    wheels = 2
    # The number of queues for each wheel
    queues = 256
  }

  camp {
    # Precision parameter
    precision = 5
  }

  trace {
    # files: reads from the trace file(s)
    # synthetic: reads from a synthetic generator
    source = files

    # The number of events to skip
    skip = 0
    # The number of events to process or null if unbounded
    limit = null
  }

  files {
    # The paths to the trace files or the file names if in the format's package. To use a mix of
    # formats, specify the entry in the form "{format}:{path}", e.g. "lirs:loop.trace.gz".
    paths = [ multi1.trace.gz ]

    # arc: format from the authors of the ARC algorithm
    # adapt-size: format from the authors of the AdaptSize algorithm
    # address: format of UCSD program address traces
    # address-penalties: format of UCSD program address traces with hit & miss penalties
    # cache2k: format from the author of the Cache2k library
    # cachelib: format from the author of the Cachelib library
    # camelab: format of the Camelab storage traces
    # cloud-physics: format of the Cloud Physics traces
    # corda: format of Corda traces
    # gl-cache: format from the authors of the GL-Cache algorithm
    # gradle: format from the authors of the Gradle build tool
    # lcs_trace: format from the authors of libCacheSim
    # lcs_twitter: format from the authors of libCacheSim
    # lirs: format from the authors of the LIRS algorithm
    # lrb: format from the authors of the LRB algorithm
    # outbrain: format of Outbrain's trace provided on Kaggle
    # scarab: format of Scarab Research traces
    # snia-cambridge: format of the SNIA MSR Cambridge traces
    # snia-k5cloud: format of the SNIA K5cloud traces
    # snia-object-store: format of the SNIA IBM ObjectStore traces
    # snia-systor: format of the SNIA SYSTOR '17 traces
    # snia-tencent-block: format of the SNIA Tencent Block traces
    # snia-tencent-photo: format of the SNIA Tencent Photo traces
    # tragen: format of the Tragen synthetic trace generator
    # twitter: format of the Twitter Cache Cluster traces
    # umass-storage: format of the University of Massachusetts storage traces
    # umass-youtube: format of the University of Massachusetts youtube traces
    # wikipedia: format of the WikiBench request traces
    format = lirs
  }

  synthetic {
    # The number of events to generate
    events = 10000

    # counter, repeating, uniform, exponential, hotspot,
    # zipfian, scrambled-zipfian, or skewed-zipfian-latest
    distribution = scrambled-zipfian

    # A sequence of unique integers starting from...
    counter.start = 1

    # A sequence of unique integers that repeats
    repeating.items = 5000

    # A sequence that is generated from the specified set uniformly randomly
    uniform {
      lower-bound = 1
      upper-bound = 1000
    }

    # A sequence based on an exponential distribution with a mean arrival rate of gamma
    exponential.mean = 1.0

    # A sequence resembling a hotspot distribution where x% of operations access y% of data items
    hotspot {
      # The lower bound of the distribution
      lower-bound = 1
      # The upper bound of the distribution
      upper-bound = 1000
      # The percentage of the of the interval which comprises the hot set
      hotset-fraction = 0.25
      # The percentage of operations that access the hot set
      hot-opn-fraction = 0.25
    }

    # A sequence where some items are more popular than others, according to a zipfian distribution
    zipfian {
      # The number of items
      items = 5000

      # The skewness factor
      constant = 0.99

      # A zipfian sequence that scatters the "popular" items across the item space. Use if you don't
      # want the head of the distribution (the popular items) clustered together.
      scrambled {}

      # A zipfian sequence with a popularity distribution of items, skewed to favor recent items
      # significantly more than older items
      skewed-zipfian-latest {}
    }
  }
}