Contents

Introduction

The Preemptive Cache class

How to Use the Class in Our Scripts

Other Uses

Conclusion

Introduction

The first part of this article presented techniques to profile and detect slow code. It also describes how caching can often provide great performance improvements in many cases that cause your application code to be too slow.

In this part of the article it is presented a solution that uses a caching class to solve a real problem in practice, in the case accessing database records.

The Preemptive Cache class

The Preemptive Cache class was created to fetch any type of data and keep frequently accessed data in memory in a private array with some extra features.

The way the class works is pretty simple. When we create an object, we pass a closure (callback function) with the code that retrieves the data that the application needs. This idea of passing a closure function is to make it generic so it is independent of the origin the data.

The class simply stores the data in memory in a private array, so it becomes immediately available in case the application needs to retrieve the same record of data.

 php script.php -h"host" -u"user" -p"password" -d"database"

In my tests, in order to obtain interesting values, I have used 100.000 records for data table, 10.000 products and 1.000 families.

The idea with this is trying to simulate a realistic behaviour. To be honest, reading 1000 records probably does not need a cache like that.

All the records generated for data, products and family tables are randomized, maybe your results and mine may differ for this reason.

The important thing is that you understand the process and that you can encounter with a similar problem in the future.

All the process last long time with these premises, for this reason I have implemented a little progress bar to not desperate while the process take action.

The results of the execution of the unoptimized script already were seen in the first part of this article, let me show the quantity of seconds that this script lasts.

And, when run the optimized script the result is this one:

Keep in mind, that if we limit too much the quantity of records that the cache will keep in memory, It will most likely increase our execution time instead of decrease. In this simple example you can see that we are assigning 1000 records in the cache constructor.

In the real life, when the script has to do a lot of things and connect with an external server the slowdown probably does not matter. In my local environment with any number less than the total of records to read the optimized script takes more time than the unoptimized one.

Here is the part of the constructor call.

$familyCache = new PreEmptiveCache( function($id) use ($conn) {
    return mysqli_query(
        $conn,
        sprintf(
            'SELECT `p`.`name` AS `product_name`, `p`.`ratio` AS `product_ratio`, '.
            '`p`.`family_id` AS `family_id`, `f`.`name` AS `family_name`, `f`.`ratio` AS `family_ratio` ' .
            'FROM `product` as `p` '.
            'LEFT JOIN `family` AS `f` ON `p`.`family_id`=`f`.`id` '.
            'WHERE `p`.`id`= %d',
            $id
        )
    )->fetch_assoc();
}, array(
    'maxRecordsCached' => 99999,
    'mode' => PreEmptiveCache:: LESS_OLDEST_MODE,
    'debug' => $debug,
));

Other Uses

We can use this simple cache system to improve the performance not only when accessing data from a database, but also when accessing a remote service, like weather forecasts, currency exchange rates, last tweets, etc..

All the data that is susceptible to be stored to prevent access again to an expensive resource can be handled with this method, and so improve the performance results of the script because we do not need to access again to the source of data so frequently. Obviously we need to be certain that the data does not change while our script is running.

Conclusion

In this article we have learned to how to increase the performance of scripts using caching to avoid accessing repeatedly expensive resources that do not change frequently. This is a general solution that can be used in many performance problems, including the ones that you may be having in your current projects.

If you liked this article or have questions regarding the performance optimization through the caching approach presented here, post a comment the this article here.