similus 0.1.1

data/LICENSES

@@ -0,0 +1,23 @@
+The MIT License
+ 
+Copyright (c) 2010 Horaci Cuevas
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Manifest

@@ -0,0 +1,16 @@
+LICENSES
+README.rdoc
+Rakefile
+benchmarks/benchmark1.rb
+benchmarks/benchmark2.rb
+benchmarks/custom_benchmark.rb
+benchmarks/redis.conf
+init.rb
+lib/similus.rb
+lib/similus/config.rb
+lib/similus/core.rb
+lib/similus/redis.rb
+test/add_activity_spec.rb
+test/recommended_spec.rb
+test/similar_spec.rb
+Manifest

data/README.rdoc

@@ -0,0 +1,80 @@
+= Similus
+
+Similus is a Ruby library that allows to find similar objects and recommendations using generated activity.
+Examples of usage:
+
+* Find similar articles to another one based on what other users also viewed.
+* Recommend articles to a user based on similar activity of other users.
+
+== Authors
+
+{Horaci Cuevas}[http://github.com/horaci] <horaci@gmail.com>
+
+== Quick overview
+
+* Setup
+* Store activity
+* Show similar objects
+* Show recommended objects
+
+== Setup
+
+Before using Similus, you need to setup the redis configuration. In rails this can be done inside a preinitializer in the config/preinitializers folder.
+
+  Similus.config do |config|
+    config.backend = :redis
+    config.redis_server = "localhost:6379"
+    config.redis_db = 8
+  end
+
+=== Store activity
+
+Locate where you want to store activity. For example, in Ruby on Rails, inside the show method of the ArticlesController class: 
+
+  class ArticlesController < ApplicationController
+    def show
+      @article = Article.find(params[:id])
+      Similus.add_activity(current_user, :show, @article)
+    end
+  end
+
+=== Show similar objects
+
+Once there is some activity stored by users, you can query for similar objects:
+
+class ArticlesController < ApplicationController
+  def show
+    @article = Article.find(params[:id])
+    @similar_articles = Similus.similar_to(@article)
+  end
+end
+
+=== Show recommended objects
+
+Even better than just showing similar articles, show recommended articles for the user's previous activity when there is a logged in user:
+
+class HomeController < ApplicationController
+  def index
+    @recommended_articles = Similus.recommended_for(current_user, :target => "Article")
+  end
+end
+
+== Configuring and installing Similus
+
+As of current version, Similus only supports redis backend. Thus, you need the redis gem and a redis server started. 
+
+* Install Redis 2.0 from [http://code.google.com/p/redis/]
+
+* Install the redis gem
+
+  gem install redis
+  
+* Install the Similus gem
+
+  gem install similus
+
+== License
+
+Copyright (c) 2010 Horaci Cuevas
+
+See LICENSES for details.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+require 'spec/rake/spectask'
+
+desc 'Default: run all similus tests'
+task :default => :test
+
+desc "Run all tests"
+Spec::Rake::SpecTask.new('test') do |t|
+  t.spec_files = FileList['test/**/*.rb']
+  t.spec_opts = ["--color"]
+end
+
+Echoe.new('similus', '0.1.1') do |p|
+  p.description    = "A ruby library to find similar objects and make recommendations based on activity of objects"
+  p.url            = "http://github.com/horaci/similus"
+  p.author         = "Horaci Cuevas"
+  p.email          = "horaci @@ gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end

data/benchmarks/benchmark1.rb

@@ -0,0 +1,90 @@
+require '../lib/similus.rb'
+require './custom_benchmark.rb'
+
+class SimilusBenchmark1
+  def configure_redis
+    Similus.config do |config|
+      config.backend = :redis
+      config.redis_server = "localhost:6379"
+      config.redis_db = 8
+    end
+  end
+
+  def test
+    configure_redis
+
+    [10,50,100,500,1_000,5_000,10_000,50_000,100_000,500_000,1_000_000].each do |t|
+      test_method(:add_activity, t, :param_types => [:users,:actions,:targets], :flush => true)
+      test_method(:similar_to, t, :repetitions => [t,100000].min, :method_options => {:load_objects => false})
+      test_method(:recommended_for, t, :repetitions => [t,100000].min, :method_options => {:load_objects => false})
+    end
+
+    CustomBenchmark.print_table
+  end
+
+  def test_method(method, t=1, options={})
+    options = {:param_types=>[:users], :flush=>false, :repetitions => t}.update(options)
+
+    # Preapre data
+    Similus.redis.flushdb if options[:flush]
+    users = []; actions = []; targets = []
+    options[:repetitions].times do |i|
+      users[i] = ["User", rand([2,t/10].max)+1]
+      actions[i] = [:view, :comment, :like].shuffle.first
+      targets[i] = [["Article", "Author", "User", "Comment"].shuffle.first, rand([2,t/100].max)+1]
+    end
+
+    # Repeat t times
+    CustomBenchmark.benchmark_block(method, t, options[:repetitions]) do
+      print "Start #{method} #{options[:repetitions]} (#{t}) times: "
+      options[:repetitions].times do |i|
+        print "." if i%1000 == 0 and i > 0
+        params = []
+        params << users[i]   if options[:param_types].include?(:users)
+        params << actions[i] if options[:param_types].include?(:actions)
+        params << targets[i] if options[:param_types].include?(:targets)
+        params << options[:method_options] if options[:method_options]
+        Similus.send(method.to_sym, *params)
+      end
+      puts "Done!"
+    end
+  end
+end
+
+benchmark = SimilusBenchmark1.new
+benchmark.test
+
+
+# 28/09/2010
+#
+# (times)   :         add_activity |          similar_to |     recommended_for |
+# 10        :         10.02 (1.00) |         3.45 (0.34) |         8.50 (0.85) |
+# 50        :         39.04 (0.78) |        24.53 (0.49) |        45.48 (0.91) |
+# 100       :         73.15 (0.73) |        55.42 (0.55) |        96.05 (0.96) |
+# 500       :        422.46 (0.84) |       623.09 (1.25) |      1778.15 (3.56) |
+# 1000      :        788.63 (0.79) |      1990.06 (1.99) |      4837.11 (4.84) |
+# 5000      :       4295.17 (0.86) |     12390.42 (2.48) |     36720.16 (7.34) |
+# 10000     :       8007.07 (0.80) |     41967.76 (4.20) |   105031.32 (10.50) |
+# 50000     :      41792.52 (0.84) |    139241.77 (2.78) |    383507.61 (7.67) |
+# 100000    :      85121.77 (0.85) |    467467.67 (4.67) |  1093418.17 (10.93) |
+# 500000    :     487059.48 (0.97) |   1475465.49 (2.95) |   3576451.57 (7.15) |
+# 1000000   :     992621.05 (0.99) |   4901504.93 (4.90) | 10251016.93 (10.25) | // 1.077.523.597 objects from similar
+# 
+
+# 04/10/2010 - 1M activity dump size = 196MB
+#
+# +-----------+-----------------------+-----------------------+-----------------------+
+# |   (times) |    add_activity (avg) |      similar_to (avg) | recommended_for (avg) |
+# +-----------+-----------------------+-----------------------+-----------------------+
+# |        10 |          20.33 (2.03) |           3.43 (0.34) |           5.11 (0.51) |
+# |        50 |          43.20 (0.86) |          21.45 (0.43) |          37.15 (0.74) |
+# |       100 |          79.26 (0.79) |          47.26 (0.47) |          83.99 (0.84) |
+# |       500 |         420.71 (0.84) |         645.66 (1.29) |        1233.73 (2.47) |
+# |      1000 |         775.37 (0.78) |        2059.96 (2.06) |        3919.73 (3.92) |
+# |      5000 |        4244.56 (0.85) |       13365.46 (2.67) |       31732.53 (6.35) |
+# |     10000 |        8132.53 (0.81) |       46890.51 (4.69) |     103245.89 (10.32) |
+# |     50000 |       40575.59 (0.81) |      184494.91 (3.69) |      421366.42 (8.43) |
+# |    100000 |       83084.49 (0.83) |      662960.10 (6.63) |    1346657.15 (13.47) |
+# |    500000 |      473529.20 (0.95) |      344602.52 (3.45) |      671415.21 (6.71) |
+# |   1000000 |      969757.84 (0.97) |      566429.01 (5.66) |      986263.44 (9.86) |
+# +-----------+-----------------------+-----------------------+-----------------------+

data/benchmarks/benchmark2.rb

@@ -0,0 +1,92 @@
+require '../lib/similus.rb'
+require './custom_benchmark.rb'
+require 'csv'
+require 'pp'
+
+# Configure redis
+Similus.config do |config|
+  config.backend = :redis
+  config.redis_server = "localhost:6379"
+  config.redis_db = 7
+end
+
+# Clear data
+Similus.clear_database!
+
+# Download entree-database
+unless File.directory? "./entree-database"
+  `wget http://archive.ics.uci.edu/ml/databases/entree/entree_data.tar.gz`
+  `mkdir entree-database && cd entree-database && tar -zxvf ../entree_data.tar.g`
+end
+
+# Load chicago restaurants
+restaurants = {}
+print "Loading restaurants... "
+CSV.open('./entree-database/entree/data/chicago.txt','r', :col_sep => "\t").each do |row|
+  restaurants[row[0].to_i] = {
+    :name => row[1],
+    :features => row[2].split(" ").map(&:to_i)
+  }
+end
+
+puts "Done!"
+
+features = {}
+print "Loading features... "
+CSV.open('./entree-database/entree/data/features.txt','r', :col_sep => "\t").each do |row|
+  features[row[0].to_i] = row[1]
+end
+puts "Done!"
+
+# Load activity
+users = {}
+puts "Loading activity... "
+Dir.glob(File.join("./entree-database/entree/session/", "session.*")).sort.each do |file|
+  print "File #{file}: "
+  pos = 0
+  CSV.open(file,'r', :col_sep => "\t").each do |row|
+    print "." if (pos += 1) % 100 == 0
+    date = row.shift; user = row.shift; origin =row.shift
+    pages = row.map { |x| x.gsub(/[^0-9]/, "").to_i }.reject { |x| x == 0 }
+
+    users[user] ||= {
+      :pages => [],
+      :landings => [],
+    }
+    users[user][:pages] += pages
+    users[user][:landings] << pages.last if pages.last > 0 
+
+    pages.each do |page|
+      Similus.add_activity(["User",user], :view, ["Restaurant",page])
+    end
+  end
+  puts " Done!"
+end
+
+count = 0
+total_score = 0
+users.each do |user_key,user|
+  break if (count += 1) > 500 # First 500 users only
+  best_score = 0
+  best_choice = nil
+  Similus.recommended_for(["User",user_key]).each do |rec|
+    user[:landings].each do |landing|
+      rfm = (restaurants[rec[:id].to_i][:features] & restaurants[landing.to_i][:features]).size
+      if rfm > best_score
+        best_score = rfm
+        best_choice = rec[:id].to_i
+      end
+    end
+  end
+
+  print "#{best_score},"
+  total_score += best_score
+end
+
+puts " Done! --- Total: #{total_score}"
+
+# control data
+
+
+
+

data/benchmarks/custom_benchmark.rb

@@ -0,0 +1,41 @@
+class CustomBenchmark
+  def self.benchmark_block(txtlabel, counter_container=0, times_repeated=nil)
+    benchmark[counter_container] ||= {}
+    now = Time.now.to_f
+    res = yield if block_given?
+    benchmark[counter_container][txtlabel] = {:total => (Time.now.to_f - now) * 1000, :times => times_repeated || counter_container}
+    res
+  end
+
+  def self.benchmark
+    @benchmark ||= {}
+  end
+
+  def self.print_table
+    labels = benchmark.first[1].keys
+    max_label_size = labels.map(&:size).max + 7
+    fmt_str = "|%10s |" + ("%#{max_label_size}s |" * labels.size) + "\n"
+
+    # Header
+    print_line(labels, max_label_size)
+    printf(fmt_str, "(times)", *(labels.map { |l| "#{l} (avg)"}))
+    print_line(labels, max_label_size)
+
+    # Body
+    benchmark.each do |t,bench|
+      values = labels.map do |txtlabel|
+        sprintf("%.2f", bench[txtlabel][:total]) + " (" + sprintf("%.2f", bench[txtlabel][:total]/bench[txtlabel][:times]) + ")"
+      end
+      printf(fmt_str, t, *values)
+    end
+
+    # End line
+    print_line(labels, max_label_size)
+  end
+  
+  def self.print_line(labels, max_label_size)
+    format = "+%10s-+" + ("%#{max_label_size}s-+" * labels.size) + "\n"
+    label_lines = ['-'*max_label_size]*labels.size
+    printf(format, "-"*10, *label_lines)
+  end
+end

data/benchmarks/redis.conf

@@ -0,0 +1,312 @@
+# Redis configuration file example
+
+# Note on units: when memory size is needed, it is possible to specifiy
+# it in the usual form of 1k 5GB 4M and so forth:
+#
+# 1k => 1000 bytes
+# 1kb => 1024 bytes
+# 1m => 1000000 bytes
+# 1mb => 1024*1024 bytes
+# 1g => 1000000000 bytes
+# 1gb => 1024*1024*1024 bytes
+#
+# units are case insensitive so 1GB 1Gb 1gB are all the same.
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
+# default. You can specify a custom pid file location here.
+pidfile /var/run/redis.pid
+
+# Accept connections on the specified port, default is 6379
+port 6379
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for incoming connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# verbose (many rarely useful info, but not a mess like the debug level)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel verbose
+
+# Specify the log file name. Also 'stdout' can be used to force
+# Redis to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################ SNAPSHOTTING  #################################
+#
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+#
+#   Note: you can disable saving at all commenting all the "save" lines.
+
+save 900 1
+save 300 10
+save 60 10000
+
+# Compress string objects using LZF when dump .rdb databases?
+# For default that's set to 'yes' as it's almost always a win.
+# If you want to save some CPU in the saving child set it to 'no' but
+# the dataset will likely be bigger if you have compressible values or keys.
+rdbcompression yes
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# The working directory.
+#
+# The DB will be written inside this directory, with the filename specified
+# above using the 'dbfilename' configuration directive.
+# 
+# Also the Append Only File will be created inside this directory.
+# 
+# Note that you must specify a directory here, not a file name.
+dir ./
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+#
+# slaveof <masterip> <masterport>
+
+# If the master is password protected (using the "requirepass" configuration
+# directive below) it is possible to tell the slave to authenticate before
+# starting the replication synchronization process, otherwise the master will
+# refuse the slave request.
+#
+# masterauth <master-password>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+# 
+# Warning: since Redis is pretty fast an outside user can try up to
+# 150k passwords per second against a good box. This means that you should
+# use a very strong password otherwise it will be very easy to break.
+#
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limits.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+#
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+#
+# maxmemory <bytes>
+
+############################## APPEND ONLY MODE ###############################
+
+# By default Redis asynchronously dumps the dataset on disk. If you can live
+# with the idea that the latest records will be lost if something like a crash
+# happens this is the preferred way to run Redis. If instead you care a lot
+# about your data and don't want to that a single record can get lost you should
+# enable the append only mode: when this mode is enabled Redis will append
+# every write operation received in the file appendonly.aof. This file will
+# be read on startup in order to rebuild the full dataset in memory.
+#
+# Note that you can have both the async dumps and the append only file if you
+# like (you have to comment the "save" statements above to disable the dumps).
+# Still if append only mode is enabled Redis will load the data from the
+# log file at startup ignoring the dump.rdb file.
+#
+# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
+# log file in background when it gets too big.
+
+appendonly no
+
+# The name of the append only file (default: "appendonly.aof")
+# appendfilename appendonly.aof
+
+# The fsync() call tells the Operating System to actually write data on disk
+# instead to wait for more data in the output buffer. Some OS will really flush 
+# data on disk, some other OS will just try to do it ASAP.
+#
+# Redis supports three different modes:
+#
+# no: don't fsync, just let the OS flush the data when it wants. Faster.
+# always: fsync after every write to the append only log . Slow, Safest.
+# everysec: fsync only if one second passed since the last fsync. Compromise.
+#
+# The default is "everysec" that's usually the right compromise between
+# speed and data safety. It's up to you to understand if you can relax this to
+# "no" that will will let the operating system flush the output buffer when
+# it wants, for better performances (but if you can live with the idea of
+# some data loss consider the default persistence mode that's snapshotting),
+# or on the contrary, use "always" that's very slow but a bit safer than
+# everysec.
+#
+# If unsure, use "everysec".
+
+# appendfsync always
+appendfsync everysec
+# appendfsync no
+
+################################ VIRTUAL MEMORY ###############################
+
+# Virtual Memory allows Redis to work with datasets bigger than the actual
+# amount of RAM needed to hold the whole dataset in memory.
+# In order to do so very used keys are taken in memory while the other keys
+# are swapped into a swap file, similarly to what operating systems do
+# with memory pages.
+#
+# To enable VM just set 'vm-enabled' to yes, and set the following three
+# VM parameters accordingly to your needs.
+
+vm-enabled no
+# vm-enabled yes
+
+# This is the path of the Redis swap file. As you can guess, swap files
+# can't be shared by different Redis instances, so make sure to use a swap
+# file for every redis process you are running. Redis will complain if the
+# swap file is already in use.
+#
+# The best kind of storage for the Redis swap file (that's accessed at random) 
+# is a Solid State Disk (SSD).
+#
+# *** WARNING *** if you are using a shared hosting the default of putting
+# the swap file under /tmp is not secure. Create a dir with access granted
+# only to Redis user and configure Redis to create the swap file there.
+vm-swap-file /tmp/redis.swap
+
+# vm-max-memory configures the VM to use at max the specified amount of
+# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
+# is, if there is still enough contiguous space in the swap file.
+#
+# With vm-max-memory 0 the system will swap everything it can. Not a good
+# default, just specify the max amount of RAM you can in bytes, but it's
+# better to leave some margin. For instance specify an amount of RAM
+# that's more or less between 60 and 80% of your free RAM.
+vm-max-memory 0
+
+# Redis swap files is split into pages. An object can be saved using multiple
+# contiguous pages, but pages can't be shared between different objects.
+# So if your page is too big, small objects swapped out on disk will waste
+# a lot of space. If you page is too small, there is less space in the swap
+# file (assuming you configured the same number of total swap file pages).
+#
+# If you use a lot of small objects, use a page size of 64 or 32 bytes.
+# If you use a lot of big objects, use a bigger page size.
+# If unsure, use the default :)
+vm-page-size 32
+
+# Number of total memory pages in the swap file.
+# Given that the page table (a bitmap of free/used pages) is taken in memory,
+# every 8 pages on disk will consume 1 byte of RAM.
+#
+# The total swap size is vm-page-size * vm-pages
+#
+# With the default of 32-bytes memory pages and 134217728 pages Redis will
+# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
+#
+# It's better to use the smallest acceptable value for your application,
+# but the default is large in order to work in most conditions.
+vm-pages 134217728
+
+# Max number of VM I/O threads running at the same time.
+# This threads are used to read/write data from/to swap file, since they
+# also encode and decode objects from disk to memory or the reverse, a bigger
+# number of threads can help with big objects even if they can't help with
+# I/O itself as the physical device may not be able to couple with many
+# reads/writes operations at the same time.
+#
+# The special value of 0 turn off threaded I/O and enables the blocking
+# Virtual Memory implementation.
+vm-max-threads 4
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes
+
+# Hashes are encoded in a special way (much more memory efficient) when they
+# have at max a given numer of elements, and the biggest element does not
+# exceed a given threshold. You can configure this limits with the following
+# configuration directives.
+hash-max-zipmap-entries 64
+hash-max-zipmap-value 512
+
+# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
+# order to help rehashing the main Redis hash table (the one mapping top-level
+# keys to values). The hash table implementation redis uses (see dict.c)
+# performs a lazy rehashing: the more operation you run into an hash table
+# that is rhashing, the more rehashing "steps" are performed, so if the
+# server is idle the rehashing is never complete and some more memory is used
+# by the hash table.
+# 
+# The default is to use this millisecond 10 times every second in order to
+# active rehashing the main dictionaries, freeing memory when possible.
+#
+# If unsure:
+# use "activerehashing no" if you have hard latency requirements and it is
+# not a good thing in your environment that Redis can reply form time to time
+# to queries with 2 milliseconds delay.
+#
+# use "activerehashing yes" if you don't have such hard requirements but
+# want to free memory asap when possible.
+activerehashing yes
+
+################################## INCLUDES ###################################
+
+# Include one or more other config files here.  This is useful if you
+# have a standard template that goes to all redis server but also need
+# to customize a few per-server settings.  Include files can include
+# other files, so use this wisely.
+#
+# include /path/to/local.conf
+# include /path/to/other.conf