PHP 5.3 introduced some new data structures. The talk of Jurriën Stutterheim on PFCongres 2011 on SPL structures and their performance triggered me to have a closer look at the performance of these structures. I was kind of fooled by two comments on the PHP.net page, so it was time to find out myself.

For people familiar with Java the SplFixedArray is not a strange structure as they are common structures in this language. PHP only used arrays in the past.

The common array structure may contain all kind of keys (one can use strings, integers and even combine them) and under the hood PHP uses a hashing algorithm to create a unique array index for these keys. So actually under the hood these arrays are comparable to Java HashMaps. Like a database can create indexes on keys, PHP creates an index on the hashed indexes to speed up item retrieval from the array. However: hashing does not guarantee a unique output for every unique input. It may well be that two completely different keys result in a same hashed value. A hashing algorithm can sort this out in its own way (there are various way to do this, but I think this is out of the scope of this post right now), so there's another level of complexity here.

The new SplFixedArray has a pre-defined size and can only contain integer keys. As the size is limited this saves memory and the indexing is done more efficient. It does away with all hashing related issues which saves time. Now the question is: how much time does it save me?

Hey: we're running PHP, not Java.. I didn't have to bother with memory usage, why would I do that now all of a sudden?

You don't have to if you don't like to, but there may be a lot to gain for you. Especially when you are using a lot of arrays of which you know the size beforehand as well as the positions of items. In an environment which often is under heavy load the benefits of SplFixedArray may come in handy for you. (And updating software is cheaper than updating hardware..)

Numbers

As I said I was fooled at first by two comments on the PHP.net manual: this one and this one.

The first one tests the speed of insertions in the regular array and the speed of insertions in the SplFixedArray and returns all positives for the SplFixedArray.

The latter one claims to be more realistic, but results in a fatal error directly because the author is trying to insert items on positions outside the range of the SplFixedArray (index out of bounds exception, also common in Java). If this is a realistic example I would reconsider using PHP

I've compiled a simple script to test the speeds and memory sizes of array vs SplFixedArray. To (kind of) prevent small background processes influencing the results these tests are done multiple times and averaged. The results are shown below. Please note that these results may vary every time you execute the script. However: the larger the size of the array, the less variance occurs and the more reliable the numbers are.

script:

<?php

$maxSize = (int) $_GET['size'];
$times = (int) $_GET['times'];

set_time_limit(0);

echo "<h2>Number of repeated tests: " . $times . "</h2>";
echo "<table border='1'>";
echo "<thead><tr><th>Items</th><th>Time Array</th><th>Memory Array</th><th>SplFixedArray</th><th>Memory SplFixedArray</th><th>Array/SplFixedArray ratio</th><th>Speed increase by SplFixedArray</th><th>Memory reduction by SplFixedArray</th></tr></thead>";
echo "<tbody>";

for($size = 1000; $size < $maxSize; $size *= 2) {
	
	echo "<tr><td align='right'>" . $size . "</td>";
	
	$arrTotal = 0;
	$arrMemUsage = 0;
	for($time = 0; $time < $times; $time++){
		$mStart = memory_get_usage();
		$container1 = array();
		for($s = microtime(true), $i = 0; $i < $size; $i++) {
			$container1[$i] = 1;
		}
		
		$arrMemUsage += (memory_get_usage() - $mStart);
		$arrTime = (microtime(true) - $s);
		$arrTotal += $arrTime;
	}
	
	$avgArrMem = ($arrMemUsage / $times);
	$avgArr = ($arrTotal / $times);
	echo "<td align='right'>" . $avgArr  . "</td>";
	echo "<td align='right'>" . $avgArrMem . "</td>";
	// Cleanup to REDUCE the influence of memory blocks on the result
	unset($arrTotal);
	unset($arrMemUsage);
	unset($container1);
	
	$splFixedArrTotal = 0;
	$splFixedArrMemUsage = 0;
	for($time = 0; $time < $times; $time++){
		$mStart = memory_get_usage();
		$container2 = new SplFixedArray($size);
		for($s = microtime(true), $i = 0; $i < $size; $i++) {
			$container2[$i] = 1;
		}
		
		$splFixedArrMemUsage += (memory_get_usage() - $mStart);
		$splFixedArrTime = (microtime(true) - $s);
		$splFixedArrTotal += $splFixedArrTime;
	}
	
	$avgSplFixedArrMem = ($splFixedArrMemUsage / $times);
	$avgSplFixedArr = ($splFixedArrTotal / $times);
	echo "<td align='right'>" . $avgSplFixedArr . "</td>";
	echo "<td align='right'>" . $avgSplFixedArrMem . "</td>";
	// Cleanup to REDUCE the influence of memory blocks on the result
	unset($splFixedArrTotal);
	unset($splFixedArrMemUsage);
	unset($container2);
	
	// Calculate ratio
	echo "<td align='right'>" . ($avgArr / $avgSplFixedArr) . "</td>";
	// Calculate speed increase percentage
	echo "<td align='right'>" . number_format(((($avgSplFixedArr - $avgArr) / $avgArr) * -100), 4) . " %</td>";
	// Calculated memory reduction percentage
	if ($avgArrMem == 0){
		echo "<td align='right'>NaN</td></tr>";
	}
	else {
		echo "<td align='right'>" . number_format(((($avgSplFixedArrMem - $avgArrMem) / $avgArrMem) * -100), 4) . " %</td></tr>";
	}
	
	// Cleanup to REDUCE the influence of memory blocks on the result
	unset($avgArr);
	unset($avgSplFixedArr);

}

echo "</tbody></table>";

?>

results:

Results (regular table didn't fit the page)

So what does it say?

Well regarding the memory the usage has been decreased by around 58% in this case. This, of course, is due to the fact that the SplFixedArray has a limited size and therefor a (pre-defined) limited space in the memory reserved. There is some gain in speed as well.

So is it better to use?

That really depends. The SplFixedArray has some advantages, but also some drawbacks compared to the common array. It should be used where it fits: if you need an array of a size which can be pre-defined and where you need integer keys. It's also a good (at least, I think.. but I started with Java..) habit to use the appropriate data structures.

I was looking for options on how to check if a certain substring (in my case ' FROM ') is present in a SQL query string when I found this blog entry. Just for fun I decided to have a look at how fast these checks would be compared to each other.

I was dealing with a two queries, knowing:

SELECT oid,typname,typlen,typlem,typdefault,typbasetype,typnotnull,typtype
FROM pg_type;

And

SELECT attname,attnum,atttypid,attndims,attnotnull,atthasdef,
pg_get_expr(adbin,adrelid) AS adbin
FROM pg_attribute LEFT JOIN pg_attrdef ON attrelid = adrelid AND attnum = adnum
WHERE attisdropped = false AND attnum > 0 AND attrelid IN
( SELECT oid FROM pg_class WHERE relname=%s AND relkind='r' ORDER BY attnum);

The code is pretty simple:

import time
t1 = time.time()
      if ' FROM ' in query:
          print 'IN found it!'
      t2 = time.time()
      print "Took me " + str(t2-t1) + " sec."
 
      t3 = time.time()
      if query.find(' FROM ') != -1:
          print 'FIND found it!'
      t4 = time.time()
      print "Took me " + str(t4-t3) + " sec."

The results look as follows:

IN found it!
Took me 4.72068786621e-05 sec.
FIND found it!
Took me 1.09672546387e-05 sec.
IN found it!
Took me 4.19616699219e-05 sec.
FIND found it!
Took me 1.12056732178e-05 sec.
IN found it!
Took me 3.48091125488e-05 sec.
FIND found it!
Took me 9.05990600586e-06 sec.
Took me 1.90734863281e-06 sec.
Took me 5.00679016113e-06 sec.
IN found it!
Took me 2.59876251221e-05 sec.
FIND found it!
Took me 1.19209289551e-05 sec.
Took me 9.53674316406e-07 sec.
Took me 1.90734863281e-06 sec.
IN found it!
Took me 0.00103211402893 sec.
FIND found it!
Took me 2.50339508057e-05 sec.
Took me 9.53674316406e-07 sec.
Took me 4.05311584473e-06 sec.

As we can see: if we use the if-in test, we get only one result even if there are more instances of ' FROM ' in the string. When using the find method, all instances are retrieved. When having only one instance in your string, the find method is usually faster. When having multiple instances, the if-in test will be faster.
It doesn't make much sense with small strings, but if you're just interested in finding a substring one or more times in a large string or a piece of text, it can make a difference.
So far my little experiment. Knowing the answer, I can sleep well again tonight