There has been some delay since the last time I’ve presented some stuff in this blog - sorry about that. I guess I can somewhat blame it on my work which is requiring a whole lot of my time nowadays. However, today I have an interesting concept to discuss. Namely the concept of applications and cache.

Nowadays, delays in software is a factor which could mean the difference between failure and success. So, how does most applications cope with this challenge? Well, some does a significant amount of work in regards to create more efficient algorithms, others focus primarily on the overall design of the application in order to reduce time delays, and also the widespread usage of compression of the data flow between systems. Not that these things is not worth thinking of, but an often forgot concept is the usage of a caching system.

A caching system would in this context mean a system specifically designed to hold “fresh data”, in a much similar way as a standard database. Now you may think, “why not just use the database?”. Well, we will in most cases use a database. However, when your web page (or application) has a wide range of users, and a large set of those users request the same set of data, then your database would be overwhelmed by the amount of incoming requests. A database has a large overhead as a result of all the features which it needs to support (think of JOIN operations, RELATIONS, CONSTRAINTS, etc), and therefore there would be a need to have a much faster retrieval of “fresh data” which is frequently requested.

How do you think Digg, Reddit or Slashdot handles its requests? 1. Route HTTP request to web application. 2. Execute a SQL SELECT statement to retrieve the articles 3. Render and return the HTML ? That would not scale very well for such large web sites. Instead, they take advantage of a caching system to hold the result of a SQL SELECT statement for a defined amount of time, and then re-initiate the SQL SELECT statement. With such an approach the database server would be much less overwhelmed by the frequent requests, and the caching system, which just holds the data, would take over the load. Since the caching system is built to hold data in memory, and to make it easy and fast retrievable, the data would be much faster loaded into the application, thus reducing the time delay previously involved.

Enough “mombo-jombo”, lets talk technical. The Danga Interactive memcached is a “high-performance, distributed memory object caching system”. Its main purpose is to hold objects in a distributed manner, and to provide fast retrieval of those objects. This is done with the help of a distributed hash table across the nodes running memcached. Setting up and running a memcached server on Ubuntu and Debian is trivial:

This would fire up a memcached server with 2GB of memory on IP 192.168.0.10:12345. Now, given the usage of python and the python memcached client library (libmcache):

1
2
3
4
5
6
7
8

import sys
try:
   import memcache
except ImportError:
   sys.exit(0)
mc = memcache.Client( ['192.168.0.10:12345'] )
mc.set("fellinghaug", "rocks")
assert mc.get("fellinghaug") == "rocks"

This may not be the best example of the usage of memcached, but the basic principle is shown. I would highly recommend reading the FAQ/Wiki at Danga’s homepage, and further these articles:

• http://en.wikipedia.org/wiki/Memcached
• http://www.linuxjournal.com/article/7451

As a final note: if your application shares the characteristics described in this article, then you should consider using a caching system.

Now, lately I’ve been experimenting on some IR-software (http://lucene.apache.org), and for these experiments I needed to clear the internal page caching of I/O data. Basicly, whenever I open a file, then Linux caches that particular file, so that if I need it again later on, it will be available in “no-time”. For my experiments, I needed a “clean” cache for every run, and therefor needed to clear my cache.

After some Googling I stumbled upon this site: http://linux-mm.org/Drop_Caches. There was a lot of interessting stuff there, so I would recommend people to read it.

Basically, whenever you need to uncache something in your computer, you can (in Linux that is), write the following in a terminal:

This one below will free pagecache:

This one below will free dentries and inodes:

This one below will free both pagecache, dentries and inodes: