add performance tests

Author: nekufa

README.md

@@ -20,6 +20,7 @@
 - [User-defined classes plugin](#user-defined-classes-plugin)
 - [Annotation plugin](#annotation-plugin)
 - [Internals](#internals)
+- [Performance](#performance)
 
 ## Installation
 The recommended way to install the library is through [Composer](http://getcomposer.org):
@@ -399,3 +400,16 @@ $mapper->getRepository('person')->findOne(['name' => 'Dmitry']);
 // you can flush cache manually
 $mapper->getRepository('person')->flushCache();
 ```
+
+## Performance
+Mapper overhead depends on amount of rows and operation type.
+Table contains overhead in **milliseconds** per entity. In some cases, overhead can't be calculated due float precision.
+
+| Operation | 100 | 1000 | 10 000 | 100 000 |
+| --- | --- | --- | --- | --- |
+| create entity one by one | 0.017 | 0.022 | 0.023 | 0.024 |
+| select entity one by one | - | 0.015 | 0.016 | 0.018 |
+| one select for all entites | - | - | 0.002 | 0.006 |
+
+Perfomance test was made on (intel i5-6400), bash for windows 10 using php 7.0.18.
+For example, when select will create 10 000 entites overhead will be 19ms.

src/Client.php

@@ -34,6 +34,15 @@ private function log($start, $class, $request = [], $response = [])
         }
     }
 
+    public function getTimeSummary()
+    {
+        $summary = 0;
+        foreach($this->log as $request) {
+            $summary += $request[0];
+        }
+        return $summary;
+    }
+
     public function setLogging($logging)
     {
         $this->logging = $logging;
@@ -44,4 +53,4 @@ public function getLog()
         return $this->log;
     }
 
-}
+}

src/Repository.php

@@ -89,9 +89,10 @@ public function findOne($params = [])
 
     public function find($params = [], $one = false)
     {
-        $cacheIndex = array_search([$params, $one], $this->cache);
-        if($cacheIndex !== false) {
-            return $this->results[$cacheIndex];
+        $cacheKey = json_encode(func_get_args());
+
+        if(array_key_exists($cacheKey, $this->results)) {
+            return $this->results[$cacheKey];
         }
 
         if(!is_array($params)) {
@@ -122,9 +123,6 @@ public function find($params = [], $one = false)
             throw new Exception("No index for params ".json_encode($params));
         }
 
-        $cacheIndex = count($this->cache);
-        $this->cache[] = [$params, $one];
-
         $client = $this->space->getMapper()->getClient();
         $values = $this->space->getIndexValues($index, $params);
 
@@ -134,16 +132,16 @@ public function find($params = [], $one = false)
         foreach($data as $tuple) {
             $instance = $this->getInstance($tuple);
             if($one) {
-                return $this->results[$cacheIndex] = $instance;
+                return $this->results[$cacheKey] = $instance;
             }
             $result[] = $instance;
         }
 
         if($one) {
-            return $this->results[$cacheIndex] = null;
+            return $this->results[$cacheKey] = null;
         }
 
-        return $this->results[$cacheIndex] = $result;
+        return $this->results[$cacheKey] = $result;
     }
 
     private function getInstance($tuple)

tests/PerformanceTest.php

@@ -0,0 +1,63 @@
+<?php
+
+use Tarantool\Mapper\Client;
+use Tarantool\Mapper\Mapper;
+use Tarantool\Mapper\Schema;
+use Tarantool\Mapper\Plugins\Sequence;
+
+class PerformanceTest extends TestCase
+{
+    public $counter = 10000;
+
+    public function test()
+    {
+        $mapper = $this->createMapper();
+        $this->clean($mapper);
+
+        $mapper->getSchema()
+            ->createSpace('tester', [
+                'id' => 'unsigned',
+                'text' => 'str',
+            ])
+            ->addIndex('id');
+
+
+        $this->exec('create', 2000,  function(Mapper $mapper) {
+            foreach(range(1, $this->counter) as $id) {
+                $mapper->create('tester', [$id, "text for $id"]);
+            }
+        });
+
+        $this->exec('read ony by one', 20000,  function(Mapper $mapper) {
+            foreach(range(1, $this->counter) as $id) {
+                $mapper->findOne('tester', $id);
+            }
+        });
+
+        $this->exec('mass read', 200000,  function(Mapper $mapper) {
+            $mapper->find('tester');
+        });
+    }
+
+    private function exec($label, $value, Callable $runner)
+    {
+        $startTime = microtime(1);
+
+        $mapper = $this->createMapper();
+        $mapper->getClient()->setLogging(true);
+        $runner($mapper);
+
+        $totalTime = microtime(1) - $startTime;
+
+        $cleanTime = $totalTime - $mapper->getClient()->getTimeSummary();
+        if($cleanTime <= 0) {
+            return [$label, [$totalTime, $mapper->getClient()->getTimeSummary()]];
+        }
+
+        $mappingPerSecond = $this->counter / $cleanTime;
+        $this->assertGreaterThan($value, $mappingPerSecond, "exec: $label");
+
+        // output overhead in milliseconds per entity
+        // var_dump($label.": ".(1000 * $cleanTime / $this->counter). ' ' .$cleanTime);
+    }
+}