forked from zendframework/zendframework
-
Notifications
You must be signed in to change notification settings - Fork 0
/
MemoryManager.php
431 lines (374 loc) · 11.1 KB
/
MemoryManager.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
<?php
/**
* Zend Framework (http://framework.zend.com/)
*
* @link http://github.com/zendframework/zf2 for the canonical source repository
* @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
* @license http://framework.zend.com/license/new-bsd New BSD License
*/
namespace Zend\Memory;
use Zend\Cache\Storage\ClearByNamespaceInterface as ClearByNamespaceCacheStorage;
use Zend\Cache\Storage\FlushableInterface as FlushableCacheStorage;
use Zend\Cache\Storage\StorageInterface as CacheStorage;
/**
* Memory manager
*
* This class encapsulates memory menagement operations, when PHP works
* in limited memory mode.
*/
class MemoryManager
{
/**
* Storage cache object
*
* @var CacheStorage
*/
private $cache = null;
/**
* Memory grow limit.
* Default value is 2/3 of memory_limit php.ini variable
* Negative value means no limit
*
* @var int
*/
private $memoryLimit = -1;
/**
* Minimum value size to be swapped.
* Default value is 16K
* Negative value means that memory objects are never swapped
*
* @var int
*/
private $minSize = 16384;
/**
* Overall size of memory, used by values
*
* @var int
*/
private $memorySize = 0;
/**
* Id for next Zend\Memory object
*
* @var int
*/
private $nextId = 0;
/**
* List of candidates to unload
*
* It also represents objects access history. Last accessed objects are moved to the end of array
*
* array(
* <id> => <memory container object>,
* ...
* )
*
* @var array
*/
private $unloadCandidates = array();
/**
* List of object sizes.
*
* This list is used to calculate modification of object sizes
*
* array( <id> => <size>, ...)
*
* @var array
*/
private $sizes = array();
/**
* Last modified object
*
* It's used to reduce number of calls necessary to trace objects' modifications
* Modification is not processed by memory manager until we do not switch to another
* object.
* So we have to trace only _first_ object modification and do nothing for others
*
* @var \Zend\Memory\Container\Movable
*/
private $lastModified = null;
/**
* Unique memory manager id
*
* @var int
*/
private $managerId;
/**
* This function is intended to generate unique id, used by memory manager
*/
private function _generateMemManagerId()
{
/**
* @todo !!!
* uniqid() php function doesn't really guarantee the id to be unique
* it should be changed by something else
* (Ex. backend interface should be extended to provide this functionality)
*/
$this->managerId = str_replace('.', '_', uniqid('ZendMemManager', true)) . '_';
}
/**
* Memory manager constructor
*
* If cache is not specified, then memory objects are never swapped
*
* @param CacheStorage $cache
*/
public function __construct(CacheStorage $cache = null)
{
if ($cache === null) {
return;
}
$this->cache = $cache;
$this->_generateMemManagerId();
$memoryLimitStr = trim(ini_get('memory_limit'));
if ($memoryLimitStr != '' && $memoryLimitStr != -1) {
$this->memoryLimit = (int) $memoryLimitStr;
switch (strtolower($memoryLimitStr[strlen($memoryLimitStr) - 1])) {
case 'g':
$this->memoryLimit *= 1024;
// no break
case 'm':
$this->memoryLimit *= 1024;
// no break
case 'k':
$this->memoryLimit *= 1024;
break;
default:
break;
}
$this->memoryLimit = (int) ($this->memoryLimit*2/3);
} // No limit otherwise
}
/**
* Object destructor
*
* Clean up cache storage
*/
public function __destruct()
{
if ($this->cache !== null) {
if ($this->cache instanceof ClearByNamespaceCacheStorage) {
$this->cache->clearByNamespace($this->cache->getOptions()->getNamespace());
} elseif ($this->cache instanceof FlushableCacheStorage) {
$this->cache->flush();
}
}
}
/**
* Set memory grow limit
*
* @param int $newLimit
*/
public function setMemoryLimit($newLimit)
{
$this->memoryLimit = $newLimit;
$this->_swapCheck();
}
/**
* Get memory grow limit
*
* @return int
*/
public function getMemoryLimit()
{
return $this->memoryLimit;
}
/**
* Set minimum size of values, which may be swapped
*
* @param int $newSize
*/
public function setMinSize($newSize)
{
$this->minSize = $newSize;
}
/**
* Get minimum size of values, which may be swapped
*
* @return int
*/
public function getMinSize()
{
return $this->minSize;
}
/**
* Create new Zend\Memory value container
*
* @param string $value
* @return Container\ContainerInterface
* @throws Exception\ExceptionInterface
*/
public function create($value = '')
{
return $this->_create($value, false);
}
/**
* Create new Zend\Memory value container, which has value always
* locked in memory
*
* @param string $value
* @return Container\ContainerInterface
* @throws Exception\ExceptionInterface
*/
public function createLocked($value = '')
{
return $this->_create($value, true);
}
/**
* Create new Zend\Memory object
*
* @param string $value
* @param bool $locked
* @return \Zend\Memory\Container\ContainerInterface
* @throws \Zend\Memory\Exception\ExceptionInterface
*/
private function _create($value, $locked)
{
$id = $this->nextId++;
if ($locked || ($this->cache === null) /* Use only memory locked objects if backend is not specified */) {
return new Container\Locked($value);
}
// Commit other objects modifications
$this->_commit();
$valueObject = new Container\Movable($this, $id, $value);
// Store last object size as 0
$this->sizes[$id] = 0;
// prepare object for next modifications
$this->lastModified = $valueObject;
return new Container\AccessController($valueObject);
}
/**
* Unlink value container from memory manager
*
* Used by Memory container destroy() method
*
* @internal
* @param Container\Movable $container
* @param int $id
* @return null
*/
public function unlink(Container\Movable $container, $id)
{
if ($this->lastModified === $container) {
// Drop all object modifications
$this->lastModified = null;
unset($this->sizes[$id]);
return;
}
if (isset($this->unloadCandidates[$id])) {
unset($this->unloadCandidates[$id]);
}
$this->memorySize -= $this->sizes[$id];
unset($this->sizes[$id]);
}
/**
* Process value update
*
* @internal
* @param \Zend\Memory\Container\Movable $container
* @param int $id
*/
public function processUpdate(Container\Movable $container, $id)
{
/**
* This method is automatically invoked by memory container only once per
* "modification session", but user may call memory container touch() method
* several times depending on used algorithm. So we have to use this check
* to optimize this case.
*/
if ($container === $this->lastModified) {
return;
}
// Remove just updated object from list of candidates to unload
if (isset($this->unloadCandidates[$id])) {
unset($this->unloadCandidates[$id]);
}
// Reduce used memory mark
$this->memorySize -= $this->sizes[$id];
// Commit changes of previously modified object if necessary
$this->_commit();
$this->lastModified = $container;
}
/**
* Commit modified object and put it back to the loaded objects list
*/
private function _commit()
{
if (($container = $this->lastModified) === null) {
return;
}
$this->lastModified = null;
$id = $container->getId();
// Calculate new object size and increase used memory size by this value
$this->memorySize += ($this->sizes[$id] = strlen($container->getRef()));
if ($this->sizes[$id] > $this->minSize) {
// Move object to "unload candidates list"
$this->unloadCandidates[$id] = $container;
}
$container->startTrace();
$this->_swapCheck();
}
/**
* Check and swap objects if necessary
*
* @throws Exception\RuntimeException
*/
private function _swapCheck()
{
if ($this->memoryLimit < 0 || $this->memorySize < $this->memoryLimit) {
// Memory limit is not reached
// Do nothing
return;
}
// walk through loaded objects in access history order
foreach ($this->unloadCandidates as $id => $container) {
$this->_swap($container, $id);
unset($this->unloadCandidates[$id]);
if ($this->memorySize < $this->memoryLimit) {
// We've swapped enough objects
return;
}
}
throw new Exception\RuntimeException('Memory manager can\'t get enough space.');
}
/**
* Swap object data to disk
* Actually swaps data or only unloads it from memory,
* if object is not changed since last swap
*
* @param \Zend\Memory\Container\Movable $container
* @param int $id
*/
private function _swap(Container\Movable $container, $id)
{
if ($container->isLocked()) {
return;
}
if (!$container->isSwapped()) {
$this->cache->setItem($this->managerId . $id, $container->getRef());
}
$this->memorySize -= $this->sizes[$id];
$container->markAsSwapped();
$container->unloadValue();
}
/**
* Load value from swap file.
*
* @internal
* @param \Zend\Memory\Container\Movable $container
* @param int $id
*/
public function load(Container\Movable $container, $id)
{
$value = $this->cache->getItem($this->managerId . $id);
// Try to swap other objects if necessary
// (do not include specified object into check)
$this->memorySize += strlen($value);
$this->_swapCheck();
// Add loaded object to the end of loaded objects list
$container->setValue($value);
if ($this->sizes[$id] > $this->minSize) {
// Add object to the end of "unload candidates list"
$this->unloadCandidates[$id] = $container;
}
}
}