Getters, setters, performance

The usage of getter and setter methods instead of public attributes became very popular in the PHP community, and it's going to become the standard coding convention of so many PHP libraries and frameworks. On the other hand many developers - including me too - strongly unrecommend such convention, because of its performance overhead. I wanted to make some performance comparison for years, and today I had time to do that. In this post I would like to show what I found.

The reason for using getters and setters

The very first question that beginner/junior PHP programmers have is why should we call a method every time when we need an attribute? Well, in the case of setters, in some special cases we might want to check the new value before we assign it to the attribute. In the setter "method" we can do this, we can check the value and we can throw an exception if it's illegal. In Java we have a dedicated exception for that, called IllegalArgumentException. In PHP, many people simply throw an Exception instance, but SPL offers us a big set of more expressive exception classes.

So this is why we use setter methods. In some special cases we want to check the new value, and - to be consistent - we use trivial setter implementations for every other attributes too. Furthermore - since the attribute is hidden - we have to write a getter "method" too, which always means its trivial implementation - simply returning the attribute value. I have never seen anybody writing that any other way. You may think that you may do some calculation in a getter, but then it's not a getter, only a non-void method that's name begins with get.

In the rest of this blog post, I will assume that in 95% of the cases the setters have trivial implementation. I think this assumption is very close to real world stats, but it's just a guess. It means that

• in 5% of the cases setters really make sense
• in 95% of the cases setters are only boilerplate
• getters are always boilerplate

It's not good. Tons of boilerplate code that you have to write or generate. In fact, in Java the usage of getter-setters is only a workaround on the lack of real properties that - for example - C# has. We all know that it's not good in Java. Why is it easier to write obj.setAttr(obj.getAttr() + 1) instead of obj.attr++?

We also know that PHP developers learnt a lot from Java and applying the patterns of other OO languages like Java and Ruby helped a lot in improving the quality of PHP frameworks, libraries and applications. But I think it's very important for everybody to do it moderately - don't pick the worst of Java please. It won't make you a better programmer.

The other way - falling back to magic methods when it's needed

Happily, the PHP magic methods enable us to check the new value of an attribute before we assign it to the attribute. We don't need tons of boilerplate getter-setters, we can use public attributes instead of them. And when first time you need to have a setter, you can create a private (or protected) attribute, implement the __get() and __set() magic methods, and if any subsequent setters are needed, you just have to add minimal code. The actual implementations can be very different, sot let me show how I do this:

class MagicMethods {
 
 private $attr;
 
 public function set_attr($attr) {
     // doing some checks before it
  $this->attr = $attr;
 }
 
 public function __set($key, $val) {
  $setter = 'set_' . $key;
  if (method_exists($this, $setter)) {
   $this->$setter($val);
   return;
  }
  throw new Exception('non-existent or unaccessible property: ' . $key);
 }
 
 public function __get($key) {
  static $enabled_attributes = array('attr');
  if (in_array($key, $enabled_attributes)) {
   return $this->$key;
  }
  throw new Exception('non-existent or unaccessible property: ' . $key);
 }
 
}

In this example my $attr attribute has a setter. The __set() method checks if a setter method exists for the attribute. If yes, then it calls it, otherwise throws an exception. The __get() checks if the attribute is a "magically proxied" property or not, and if yes, then it returns its value, otherwise throws an exception. The benefits of this method:

• if you want to add a new attribute with a setter, then declare your attribute as private or protected, implement your setter, and add the property name to the $enabled_attributes array in __get().
• if you want to add a setter to an already existing attribute, then you can do it in the same way and all your existing code will still be backwards-compatible.
• you can still add public attributes, and they won't come with the performance overhead of boilerplate getters and setters, and your code won't loose consistency.

Well, the only disadvantage that I currently see is that the __get() and __set() implementations aren't really trivial (but still not too complicated), and definitely don't have any "canonical" implementation. The source code of the class is a bit less maintainable, but the code using the class is a bit more maintainable, since you can use properties instead of getter-setter methods.

Furthermore, I would like to note that if any of your properties might have an array value, then in the __set() or in the setter of the property it's recommended to package the array into an ArrayObject instance. This way $obj->attr[$x] = $y will still work, otherwise it wouldn't, since the __get() method can't return it's value by reference, so the array will be returned by value, which means that this statement would modify a copy of the original array, which doesn't make sense. To avoid such problems - well it could result in hardly detectable bugs - the zend engine warns you, and you will see a notice saying "PHP Notice: Indirect modification of overloaded property MyClass::$arr has no effect in ...".

The benchmark

So after describing both ways of working with setters, let's see the benchmark, which is the main topic of this post.

I did the benchmark using the following source, on PHP 5.3.2:

define('END_OF_TEST', "---------------------\n");

class PublicAttr {
 
 public $attr;
 
}

class GetterSetter {
 
 private $attr;
 
 
 public function getAttr() {
  return $this->attr;
 }
 
 public function setAttr($attr) {
  $this->attr = $attr;
 }
 
}


class MagicMethods {
 
 private $attr;
 
 public function set_attr($attr) {
  $this->attr = $attr;
 }
 
 public function __set($key, $val) {
  $setter = 'set_' . $key;
  if (method_exists($this, $setter)) {
   $this->$setter($val);
   return;
  }
  throw new Exception('non-existent or unaccessible property: ' . $key);
 }
 
 public function __get($key) {
  static $enabled_attributes = array('attr');
  if (in_array($key, $enabled_attributes)) {
   return $this->$key;
  }
  throw new Exception('non-existent or unaccessible property: ' . $key);
 }
 
}

$starttime = microtime(true);

$inst = new PublicAttr;
for ($i = 0; $i < 50000; ++$i) {
 $inst->attr = 10;
}

$time = microtime(true) - $starttime;
echo "writing public attribute: $time\n";

$starttime = microtime(true);

$inst = new GetterSetter;
for ($i = 0; $i < 50000; ++$i) {
 $inst->setAttr(10);
}

$time = microtime(true) - $starttime;
echo "writing with setter: $time\n";

$starttime = microtime(true);

$inst = new MagicMethods;
for ($i = 0; $i < 50000; ++$i) {
 $inst->attr = 10;
}

$time = microtime(true) - $starttime;
echo "writing via __set() : $time\n";

echo END_OF_TEST;


$starttime = microtime(true);

$inst = new PublicAttr;
for ($i = 0; $i < 50000; ++$i) {
 $x = $inst->attr;
}

$time = microtime(true) - $starttime;
echo "reading public attribute: $time\n";

$starttime = microtime(true);

$inst = new GetterSetter;
for ($i = 0; $i < 50000; ++$i) {
 $x = $inst->getAttr();
}

$time = microtime(true) - $starttime;
echo "reading by getter: $time\n";

$starttime = microtime(true);

$inst = new MagicMethods;
for ($i = 0; $i < 50000; ++$i) {
 $x = $inst->attr;
}

$time = microtime(true) - $starttime;
echo "reading via __get() : $time\n";

echo END_OF_TEST;

So I did 50.000 read and write operations on

• public attributes
• using getters and setters
• properties implemented using magic methods

And my output if the following:

writing public attribute: 0.0088019371032715
writing with setter: 0.019134998321533
writing via __set() : 0.066682100296021
---------------------
reading public attribute: 0.0075559616088867
reading by getter: 0.015810966491699
reading via __get() : 0.054592132568359
---------------------

So let's see what we have:

• getters and setters run more than 2 times longer then public attributes
• properties with magic methods run about 7.5 times longer than public attributes, and 3,5 times longer then getter-setters.

At the first glance you may think that properties with magic methods are damn slow. But as I mentioned above, I assume that in 95% of the cases the getter-setters have their trivial (boilerplate) implementation, and in such case in the 2nd method you can use public attributes, which are much faster than getter-setters.

Let's do some calculation based on the above results:
average speed of write operations using the 1st method (getter-setters): 0.0191
average speed of write operations using the 2nd method (pubilc attributes + propreties with magic methods): 0.95+0.0088 + 0.05*0.0666 = 0.0116

average speed of read operations using the 1st method (getter-setters): 0.0158
average speed of read operations using the 2nd method (pubilc attributes + propreties with magic methods): 0.95+0.0075 + 0.05*0.0545 = 0.0098

Based on these numbers one thing is sure: if you use public attributes and properties implemented using magic methods instead of the Java-style getters and setters, then the average speed of in-memory read/write operations will be much faster.

It would be hard to say how representative this benchmark is. I tried to do my best, and I believe that these numbers are close to reality.