Blazing speed with PHP's memcache extension

meta info
Friday May 6 2005

I've recently discovered something truly awesome that many of you might not know about: the extension for PHP. The extension can be obtained from the PECL website. The memcache extension is an interface to the memcached daemon which was originally developed by Danga Interactive. It's purpose at the time was speeding up LiveJournal.com which is a very heavy-traffic website. In this article I'll explain what the memcache extension is and how it can help you increase the performance of any dynamic website dramatically.

Dark Matter Pro: a premium photoblog template.

Affiliate program available

Installing the memcache extension

In order to install the memcache extension you need to install several packages on your server. Therefore this extension probably isn't for everyone because I don't think it's very widespread among providers offering shared hosting environments. What you need is the following packages *: Installation instructions are fairly straightforward which is why I'm not going to discuss those here. Once you've installed the extension you need to restart your Apache webserver. You can check whether the extension is running by using phpinfo(). If all is ok you'll see a section about memcache.

The memcached daemon

After installing the memcache extension you need to start the memcached daemon. You can do this by issueing the following command:
memcached -d -m 1024 -l 10.0.0.1 -p 11211
The switch tells it to start as a daemon. The -m switch specifies the amount of memory in megabytes. The -l switch specifies the IP to listen on and finally the -p switch specifies the port to listen on. The default port is 11211 and if your machine has just 1 IP you can omit the -l parameter. In the above example I set the amount of memory to 1GB. Of course you should use a sensible amount of memory. Making your machine swap to disk sort of defeats the purpose of a memory cache daemon. Note that it's perfectly fine to run the memcached daemon on another machine than the one you're running your actual PHP project on. You could even set up a machine totally dedicated to being a memory cache server. And if that's not even enough you can set up muliple servers as well. The sky is the limit. Note: if you try to start the memcached as root it will require you to specify a user under which it should run with an additional -u switch

Using the memcache extension

The memcache extension has it's own section in the PHP manual in which the API is described. I guess not so many people have discovered this great extension yet since there aren't any user contributed notes to be found on these pages. However if you're a bit of a PHP programmer you'll probably find what you need here. In the examples here I'm keeping things simple. I'm assuming a memcached daemon running on the same machine on which the PHP project is running. The extension comes with both a procedural and an object oriented interface. Of course we're using the OO interface here, with PHP5. In order to make life as easy as possible we can create a little singleton: 
include_once("constants.php");
// Memcache singleton object
class clsMem extends Memcache {
	static private $m_objMem = NULL;
	static function getMem() {
		if (self::$m_objMem == NULL) {
			self::$m_objMem = new Memcache;
			// connect to the memcached on some 
                        //host __MEMHOST running it om __MEMPORT
			self::$m_objMem->connect(__MEMHOST, __MEMPORT) 
                        or die ("The memcached server");
		}
		return self::$m_objMem;
	}
}
In the include file constants.php I've defined __MEMHOST and __MEMPORT to be the IP number and port on my server. Excellent, we're all set up. We can start enjoying the memcache extension now. Let's look at some examples! Let's create an entry in the cache. 
$sMyString = "I'm going to be cached!";
clsMem::getMem()->set("mykey", $sMyString, false, 600) 
or die ("Could not write to the cache");
The memcache object has several methods. With the Memcache::set method we can add an entry to the cache. The method had four arguments:
  • a key
  • any serializable variable we'd like to cache, in this case it's a string
  • a boolean whether we want to use on-the-fly zip compression using libz
  • the cache expiry measured in seconds.
That's all there's to it. We've now inserted a string into the cache. Now let's suppose we want to use this string a while later in another PHP page: 
$sMyString = clsMem::getMem()->get("mykey") 
or die ("Couldn't find the requested item in the cache!");
echo $sMyString;
You've probably guessed it, it will print out the previously cached string, if we try this within 10 minutes after storing it of course. If we're too late the Memcache::get method will return false. Of course caching simple strings doesn't really make sense. The fun really starts when we cache resultsets from heavy database queries. Let's have a look at a way to do this! 
function cachedSQL($sSQL)  {
  $sSQL = "SELECT some really heavy stuff FROM some table";
  if($objResultset = clsMem::getMem()->get(MD5($sSQL))  {
    // return the cached resultset
    return $objResultSet;
    }
  else  {
    // assuming we have a PEAR::DB based database 
    // singleton handling the query
    $objResultSet = DB::getDB()->query->($sSQL);
    // Store the resultset in the cache
    clsMem::getMem()->set(MD5($sSQL), $objResultSet, true, 600);
    // return it 
    return $objResultSet;
    }
  }

Conclusion

Here we are, we now have cached SQL queries without any trouble. Of course I won't have to tell you what this can do for the performance of your (heavy load) website. As noted earlier, we can cache any PHP entity that can be serialized. This means strings, integers, objects, arrays, almost anything really. The memcache extension is easy to use with it's extremely simple interface. At this moment I'm using it to build a complex chat engine for my mobile date & chat community. At this moment every refresh on the chatboxes result in numerous SQL queries. Those will all be gone very soon and all chat activity (which is volatile data anyway) will be stored in the memory cache. If you've never tried this PECL extension for PHP you should most definitely check it out! Resources: *Want to on Windows? I have no idea whether that will work. Most probably not like just about everything else...
bookmarking

Commentary

Join the discussion! Leave a comment through the comment form below!

Got something to add to this?

Feel free to leave a comment on this site. You can use Textile and Emoticons. Your email address is only used to show a gravatar. Please stay on-topic and use common decency. Spammers will be shot in front of a live studio audience.

If you plan on posting code, use pastebin please and post a URL to the code. The comment processing doesn't deal very well with code. Sorry for the inconvenience.

Human comment spammers: don't bother posting your crap here. Comments are moderated and I won't let any of your shit through.

Remember personal info?
Yes
No

Trackbacks

If you have an interesting related post on your own site you can leave a trackback. As they say: 'a little AJAX a day keeps the spammers away' which is why you'll have to click below to generate a trackback key. The key will be valid for 15 minutes and can be used only once.

 

  • Featured Links
RockySomewhere near the Orion NebulaBookalicio.usGolden Gate BridgeThames River BankJackie and mePimpin' it