Piwigo.org

grum · 2010-11-18 00:52:14

Parce que de l'hôtel j'ai pas accès à tout mon environnement mais que j'ai du temps, j'ai fait un p'tit bench pour comparer les performances entre l'exécution :
- d'un code classique par objet
- d'un code objet, créé dynamiquement
- d'un code objet statique

le programme (en toute transparence) :

Code:

<?php

define('NBITER', 400);
define('TABSIZE', 1000);
define('NBTESTS', 20);

class PerfTimer {
 private $startTime;
 private $endTime;
 private $startMemory;
 private $endMemory;
 private $results=array();
 private $memory=array();

 public function start()
 {
    $this->startTime=microtime(true);
    $this->endTime=$this->startTime;
    $this->statMemory=memory_get_usage();
    $this->endMemory=$this->startMemory;
 }

 public function stop()
 {
    $this->endTime=microtime(true);
    $this->endMemory=memory_get_usage();
    return($this->time());
 }

 public function current()
 {
   return(microtime(true) - $this->startTime);
 }

 public function time()
 {
   return($this->endTime - $this->startTime);
 }

 public function memory()
 {
   return($this->endMemory - $this->startMemory);
 }

 public function push()
 {
   $this->results[]=$this->time();
   $this->memory[]=$this->memory();
 }

 public function stats()
 {
   return(
    array(
      'maxTime' => max($this->results),
      'minTime' => min($this->results),
      'avgTime' => $this->avg($this->results),
      'maxMemory' => max($this->memory),
      'minMemory' => min($this->memory),
      'avgMemory' => $this->avg($this->memory),
    )
   );
 }

 private function avg($obj)
 {
   $returned=0;
   for($i=0;$i<count($obj);$i++)
   {
     $returned+=$obj[$i];
   }
   if(count($obj)>0) $returned=$returned/count($obj);
   return($returned);
 }
}

// sort test without objet
function sortTest1($arrayv)
{
  usort($arrayv, 'compareTest1');
}
function compareTest1($a, $b)
{
  if($a==$b) return(0);
  return($a<$b?1:-1);
}

// sort test with dynamic object methods
class SortTest2
{
  private $arrayv;

  public function __construct($arrayv)
  {
    $this->arrayv=$arrayv;
  }
  public function sort()
  {
    usort($this->arrayv, array(&$this, 'compare'));
  }
  public function compare($a, $b)
  {
    if($a==$b) return(0);
    return($a<$b?1:-1);
  }
}

// sort test with static object methods
class SortTest3
{
  static public function sort($arrayv)
  {
    usort($arrayv, array('self', 'compare'));
  }
  static public function compare($a, $b)
  {
    if($a==$b) return(0);
    return($a<$b?1:-1);
  }
}

// initialize array
$arrayL=array();
for($i=TABSIZE;$i>0;$i--)
{
  $arrayL[]=$i;
}

// initialize timers
$timers=array(
  new PerfTimer(),
  new PerfTimer(),
  new PerfTimer(),
  'g' => new PerfTimer(),
);

// start test
$timers['g']->start();
for($j=1;$j<=NBTESTS;$j++)
{
  echo "Test $j ";
  $timers[0]->start();
  for($i=0;$i<NBITER;$i++)
  {
    sortTest1($arrayL);
  }
  $timers[0]->stop();
  $timers[0]->push();

  $timers[1]->start();
  for($i=0;$i<NBITER;$i++)
  {
    $o=new sortTest2($arrayL);
    $o->sort();
  }
  $timers[1]->stop();
  $timers[1]->push();

  $timers[2]->start();
  for($i=0;$i<NBITER;$i++)
  {
    sortTest3::sort($arrayL);
  }
  $timers[2]->stop();
  $timers[2]->push();

  echo "(".$timers['g']->current().")<br>";
}

// display results
echo "<pre>Results :
 Sort 1 : ".print_r($timers[0]->stats(), true)."
 Sort 2 : ".print_r($timers[1]->stats(), true)."
 Sort 3 : ".print_r($timers[2]->stats(), true)."
</pre>";

?>

Pour ceux qu'auraient la flemme de comprendre le code, le programme consiste à :
1/ Créer un tableau de 1000 éléments
2/ Effectuer 400 fois le tri du tableau selon les 3 méthodes :
- méthode 1 = fonction pas objet, tri programmé par appel d'une fonction non objet
- méthode 2 = création dynamique d'un objet, tri programmé par appel d'une méthode de l'objet créé
- méthode 3 = utilisation d'objet statique, tri programmé par appel d'une méthode statique de l'objet
3/ Le test est effectué 20fois

Sont mesurés à chaque fois pour les 400 tris:
- les temps d'exécutions
- l'utilisation de la mémoire
Les résultats, issus de traitements effectués sur les serveurs de mon hébergeur :
- La durée totale du test : environ 2minutes
- en partant du principe que le temps de traitement de la première méthode sert d'étalon

Code:

 - méthode 2 : temps d'exécution entre +2,13% et +8,16% ; utilisation de la mémoire : +1,18%
 - méthode 3 : temps d'exécution entre -4,37% et +1,52% ; utilisation de la mémoire : +1,26%

à noter que j'ai relancé plusieurs fois le test, les sollicitations du serveur pouvant varier... (par exemple, j'ai eu un résultat assez étonnant où la méthode 2 était mesurée à -0,51% par rapport à la méthode 1 alors que généralement çà semble tourner aux environs de +7% ; pour la méthode 3 à quelques exceptions près, çà tourne aux environ -0,5%)

exemple d'un résultat brut :

Code:

Sort 1 : Array
(
    [maxTime] => 1.85044002533
    [minTime] => 1.68745207787
    [avgTime] => 1.72813769579
    [maxMemory] => 224632
    [minMemory] => 166820
    [avgMemory] => 217869
)

 Sort 2 : Array
(
    [maxTime] => 2.07116794586
    [minTime] => 1.76044821739
    [avgTime] => 1.81905783415
    [maxMemory] => 224768
    [minMemory] => 215840
    [avgMemory] => 220458.8
)

 Sort 3 : Array
(
    [maxTime] => 1.85630202293
    [minTime] => 1.64068412781
    [avgTime] => 1.70598300695
    [maxMemory] => 224904
    [minMemory] => 216352
    [avgMemory] => 220623.2
)

Gotcha · 2010-11-19 09:47:44

Bonjour Grum,
Je suis totalement HS sur ton sujet mais je crois comprendre que la différence n'est pas très importante au vu du critère "tri" effectué tout de même 400 fois !
Encore une fois je n'y comprends rien mais ça semble important 400 fois pour des écarts sur les différentes méthode qui ne sautent pas aux yeux.

Désolé si mon intervention n'est pas bonne :-s

Piwigo.org

Annonce

#1 2010-11-18 00:52:14

Bench : prog. classique vs. prog. objet (dynamique & statique)

Code:

Code:

Code:

#2 2010-11-19 09:47:44

Re: Bench : prog. classique vs. prog. objet (dynamique & statique)

Pied de page des forums