MemoryLimitManager::getCurrentUsageInBytes() - Code Metrics - bazzline/php_component_memory_limit_manager - Measure and Improve Code Quality continuously with Scrutinizer

MemoryLimitManager::getCurrentUsageInBytes() A
last analyzed 2021-02-05 12:19 UTC

↳ Parent: MemoryLimitManager

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.7
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php
/**
 * @author: stev leibelt <[email protected]>
 * @since: 2014-07-27
 */

namespace Net\Bazzline\Component\MemoryLimitManager;

/**
 * Class MemoryLimitManager
 * @package Net\Bazzline\Component\Fork
 */
class MemoryLimitManager
{
    /**
     * @var int
     */
    private $bufferInBytes;

    /**
     * @var int
     */
    private $limitFromIniInBytes;

    /**
     * @var int
     */
    private $limitInBytes;

    public function __construct()
    {
        $currentMemoryLimitFromIni = trim(ini_get('memory_limit'));

        if (((int) $currentMemoryLimitFromIni) > 0) {
            $unitIdentifier = strtolower($currentMemoryLimitFromIni[strlen($currentMemoryLimitFromIni)-1]);
            $value = (int) substr($currentMemoryLimitFromIni, 0, -1);

            switch ($unitIdentifier) {
                case 'g':
                    $this->limitFromIniInBytes = ($this->gigaBytesInBytes($value));
                    break;
                case 'm':
                    $this->limitFromIniInBytes = ($this->megaBytesInBytes($value));
                    break;
                case 'k':
                    $this->limitFromIniInBytes = ($this->kiloBytesInBytes($value));
                    break;
                default:
                    $this->limitFromIniInBytes = $value;
            }
        } else {
            $this->limitFromIniInBytes = 0;
        }

        $this->limitInBytes = $this->limitFromIniInBytes;
    }

    /**
     * @param int $bytes
     */
    public function setBufferInBytes($bytes)
    {
        $this->bufferInBytes = (int) $bytes;
    }

    /**
     * @param int $kiloBytes
     */
    public function setBufferInKiloBytes($kiloBytes)
    {
        $this->setBufferInBytes($this->kiloBytesInBytes($kiloBytes));
    }

    /**
     * @param int $megaBytes
     */
    public function setBufferInMegaBytes($megaBytes)
    {
        $this->setBufferInBytes($this->megaBytesInBytes($megaBytes));
    }

    /**
     * @param int $gigaBytes
     */
    public function setBufferInGigaBytes($gigaBytes)
    {
        $this->setBufferInBytes($this->gigaBytesInBytes($gigaBytes));
    }

    /**
     * @return int
     */
    public function getBufferInBytes()
    {
        return $this->bufferInBytes;
    }

    /**
     * @return int
     */
    public function getBufferInKiloBytes()
    {
        return $this->bytesInKiloBytes($this->bufferInBytes);
    }

    /**
     * @return int
     */
    public function getBufferInMegaBytes()
    {
        return $this->bytesInMegaBytes($this->bufferInBytes);
    }

    /**
     * @return int
     */
    public function getBufferInGigaBytes()
    {
        return $this->bytesInGigaBytes($this->bufferInBytes);
    }

    /**
     * @param int $bytes
     * @throws InvalidArgumentException
     */
    public function setLimitInBytes($bytes)
    {
        if ($this->limitFromIniInBytes > 0) {
            if ($bytes > $this->limitFromIniInBytes) {
                throw new InvalidArgumentException(
                    'provided limit (' . $bytes .
                    ') is above ini limit (' .
                    $this->limitFromIniInBytes . ')',
                    1
                );
            }
        }

        $this->limitInBytes = (int) $bytes;
    }

    /**
     * @param int $kiloBytes
     * @throws InvalidArgumentException
     */
    public function setLimitInKiloBytes($kiloBytes)
    {
        $this->setLimitInBytes($this->kiloBytesInBytes($kiloBytes));
    }

    /**
     * @param int $megaBytes
     * @throws InvalidArgumentException
     */
    public function setLimitInMegaBytes($megaBytes)
    {
        $this->setLimitInBytes($this->megaBytesInBytes($megaBytes));
    }

    /**
     * @param int $gigaBytes
     * @throws InvalidArgumentException
     */
    public function setLimitInGigaBytes($gigaBytes)
    {
        $this->setLimitInBytes($this->gigaBytesInBytes($gigaBytes));
    }

    /**
     * @return int
     */
    public function getLimitInBytes()
    {
        return $this->limitInBytes;
    }

    /**
     * @return int
     */
    public function getLimitInKiloBytes()
    {
        return $this->bytesInKiloBytes($this->limitInBytes);
    }

    /**
     * @return int
     */
    public function getLimitInMegaBytes()
    {
        return $this->bytesInMegaBytes($this->limitInBytes);
    }

    /**
     * @return int
     */
    public function getLimitInGigaBytes()
    {
        return $this->bytesInGigaBytes($this->limitInBytes);
    }

    /**
     * @param array $processIds
     * @return int
     */
    public function getCurrentUsageInBytes(array $processIds = array())
    {
        $currentUsageInBytes = memory_get_usage(true);

        foreach ($processIds as $processId) {
            $return = 0;
            exec('ps -p ' . $processId . '  --no-headers -o rss', $return);

            if (isset($return[0])) {
                //non-swapped physical memory in kilo bytes
                $usageInBytes = (int) $return[0];
                $currentUsageInBytes += ($usageInBytes * 1024);
            }
        }

        return $currentUsageInBytes;
    }

    /**
     * @param array $processIds
     * @return int
     */
    public function getCurrentUsageInKiloBytes(array $processIds = array())
    {
        return $this->bytesInKiloBytes($this->getCurrentUsageInBytes($processIds));
    }

    /**
     * @param array $processIds
     * @return int
     */
    public function getCurrentUsageInMegaBytes(array $processIds = array())
    {
        return $this->bytesInMegaBytes($this->getCurrentUsageInBytes($processIds));
    }

    /**
     * @param array $processIds
     * @return int
     */
    public function getCurrentUsageInGigaBytes(array $processIds = array())
    {
        return $this->bytesInGigaBytes($this->getCurrentUsageInBytes($processIds));
    }

    /**
     * @param array $processIds
     * @return bool
     */
    public function isLimitReached(array $processIds = array())
    {
        $currentUsageInBytes = $this->getCurrentUsageInBytes($processIds);
        $currentUsageWithBufferInBytes = $currentUsageInBytes + $this->bufferInBytes;

        $isReached = ($currentUsageWithBufferInBytes >= $this->limitInBytes);

        return $isReached;
    }

    /**
     * @param int $bytes
     * @return int
     */
    private function bytesInKiloBytes($bytes)
    {
        return ((int) ($bytes / 1024));
    }

    /**
     * @param int $bytes
     * @return int
     */
    private function bytesInMegaBytes($bytes)
    {
        return ((int) ($bytes / 1048576));  //1048576 = 1024 * 1024
    }

    /**
     * @param int $bytes
     * @return int
     */
    private function bytesInGigaBytes($bytes)
    {
        return ((int) ($bytes / 1073741824));   //1073741824 = 1024 * 1024 * 1024
    }

    /**
     * @param int $kiloBytes
     * @return int
     */
    private function kiloBytesInBytes($kiloBytes)
    {
        return ((int) ($kiloBytes * 1024));
    }

    /**
     * @param int $megaBytes
     * @return int
     */
    private function megaBytesInBytes($megaBytes)
    {
        return ((int) ($megaBytes * 1048576));  //1048576 = 1024 * 1024
    }

    /**
     * @param int $gigaBytes
     * @return int
     */
    private function gigaBytesInBytes($gigaBytes)
    {
        return ((int) ($gigaBytes * 1073741824)); //1073741824 = 1024 * 1024 * 1024
    }
}


1			<?php
2			/**
3			* @author: stev leibelt <[email protected]>
4			* @since: 2014-07-27
5			*/
6
7			namespace Net\Bazzline\Component\MemoryLimitManager;
8
9			/**
10			* Class MemoryLimitManager
11			* @package Net\Bazzline\Component\Fork
12			*/
13			class MemoryLimitManager
14			{
15			/**
16			* @var int
17			*/
18			private $bufferInBytes;
19
20			/**
21			* @var int
22			*/
23			private $limitFromIniInBytes;
24
25			/**
26			* @var int
27			*/
28			private $limitInBytes;
29
30			public function __construct()
31			{
32			$currentMemoryLimitFromIni = trim(ini_get('memory_limit'));
33
34			if (((int) $currentMemoryLimitFromIni) > 0) {
35			$unitIdentifier = strtolower($currentMemoryLimitFromIni[strlen($currentMemoryLimitFromIni)-1]);
36			$value = (int) substr($currentMemoryLimitFromIni, 0, -1);
37
38			switch ($unitIdentifier) {
39			case 'g':
40			$this->limitFromIniInBytes = ($this->gigaBytesInBytes($value));
41			break;
42			case 'm':
43			$this->limitFromIniInBytes = ($this->megaBytesInBytes($value));
44			break;
45			case 'k':
46			$this->limitFromIniInBytes = ($this->kiloBytesInBytes($value));
47			break;
48			default:
49			$this->limitFromIniInBytes = $value;
50			}
51			} else {
52			$this->limitFromIniInBytes = 0;
53			}
54
55			$this->limitInBytes = $this->limitFromIniInBytes;
56			}
57
58			/**
59			* @param int $bytes
60			*/
61			public function setBufferInBytes($bytes)
62			{
63			$this->bufferInBytes = (int) $bytes;
64			}
65
66			/**
67			* @param int $kiloBytes
68			*/
69			public function setBufferInKiloBytes($kiloBytes)
70			{
71			$this->setBufferInBytes($this->kiloBytesInBytes($kiloBytes));
72			}
73
74			/**
75			* @param int $megaBytes
76			*/
77			public function setBufferInMegaBytes($megaBytes)
78			{
79			$this->setBufferInBytes($this->megaBytesInBytes($megaBytes));
80			}
81
82			/**
83			* @param int $gigaBytes
84			*/
85			public function setBufferInGigaBytes($gigaBytes)
86			{
87			$this->setBufferInBytes($this->gigaBytesInBytes($gigaBytes));
88			}
89
90			/**
91			* @return int
92			*/
93			public function getBufferInBytes()
94			{
95			return $this->bufferInBytes;
96			}
97
98			/**
99			* @return int
100			*/
101			public function getBufferInKiloBytes()
102			{
103			return $this->bytesInKiloBytes($this->bufferInBytes);
104			}
105
106			/**
107			* @return int
108			*/
109			public function getBufferInMegaBytes()
110			{
111			return $this->bytesInMegaBytes($this->bufferInBytes);
112			}
113
114			/**
115			* @return int
116			*/
117			public function getBufferInGigaBytes()
118			{
119			return $this->bytesInGigaBytes($this->bufferInBytes);
120			}
121
122			/**
123			* @param int $bytes
124			* @throws InvalidArgumentException
125			*/
126			public function setLimitInBytes($bytes)
127			{
128			if ($this->limitFromIniInBytes > 0) {
129			if ($bytes > $this->limitFromIniInBytes) {
130			throw new InvalidArgumentException(
131			'provided limit (' . $bytes .
132			') is above ini limit (' .
133			$this->limitFromIniInBytes . ')',
134			1
135			);
136			}
137			}
138
139			$this->limitInBytes = (int) $bytes;
140			}
141
142			/**
143			* @param int $kiloBytes
144			* @throws InvalidArgumentException
145			*/
146			public function setLimitInKiloBytes($kiloBytes)
147			{
148			$this->setLimitInBytes($this->kiloBytesInBytes($kiloBytes));
149			}
150
151			/**
152			* @param int $megaBytes
153			* @throws InvalidArgumentException
154			*/
155			public function setLimitInMegaBytes($megaBytes)
156			{
157			$this->setLimitInBytes($this->megaBytesInBytes($megaBytes));
158			}
159
160			/**
161			* @param int $gigaBytes
162			* @throws InvalidArgumentException
163			*/
164			public function setLimitInGigaBytes($gigaBytes)
165			{
166			$this->setLimitInBytes($this->gigaBytesInBytes($gigaBytes));
167			}
168
169			/**
170			* @return int
171			*/
172			public function getLimitInBytes()
173			{
174			return $this->limitInBytes;
175			}
176
177			/**
178			* @return int
179			*/
180			public function getLimitInKiloBytes()
181			{
182			return $this->bytesInKiloBytes($this->limitInBytes);
183			}
184
185			/**
186			* @return int
187			*/
188			public function getLimitInMegaBytes()
189			{
190			return $this->bytesInMegaBytes($this->limitInBytes);
191			}
192
193			/**
194			* @return int
195			*/
196			public function getLimitInGigaBytes()
197			{
198			return $this->bytesInGigaBytes($this->limitInBytes);
199			}
200
201			/**
202			* @param array $processIds
203			* @return int
204			*/
205			public function getCurrentUsageInBytes(array $processIds = array())
206			{
207			$currentUsageInBytes = memory_get_usage(true);
208
209			foreach ($processIds as $processId) {
210			$return = 0;
211			exec('ps -p ' . $processId . ' --no-headers -o rss', $return);
212
213			if (isset($return[0])) {
214			//non-swapped physical memory in kilo bytes
215			$usageInBytes = (int) $return[0];
216			$currentUsageInBytes += ($usageInBytes * 1024);
217			}
218			}
219
220			return $currentUsageInBytes;
221			}
222
223			/**
224			* @param array $processIds
225			* @return int
226			*/
227			public function getCurrentUsageInKiloBytes(array $processIds = array())
228			{
229			return $this->bytesInKiloBytes($this->getCurrentUsageInBytes($processIds));
230			}
231
232			/**
233			* @param array $processIds
234			* @return int
235			*/
236			public function getCurrentUsageInMegaBytes(array $processIds = array())
237			{
238			return $this->bytesInMegaBytes($this->getCurrentUsageInBytes($processIds));
239			}
240
241			/**
242			* @param array $processIds
243			* @return int
244			*/
245			public function getCurrentUsageInGigaBytes(array $processIds = array())
246			{
247			return $this->bytesInGigaBytes($this->getCurrentUsageInBytes($processIds));
248			}
249
250			/**
251			* @param array $processIds
252			* @return bool
253			*/
254			public function isLimitReached(array $processIds = array())
255			{
256			$currentUsageInBytes = $this->getCurrentUsageInBytes($processIds);
257			$currentUsageWithBufferInBytes = $currentUsageInBytes + $this->bufferInBytes;
258
259			$isReached = ($currentUsageWithBufferInBytes >= $this->limitInBytes);
260
261			return $isReached;
262			}
263
264			/**
265			* @param int $bytes
266			* @return int
267			*/
268			private function bytesInKiloBytes($bytes)
269			{
270			return ((int) ($bytes / 1024));
271			}
272
273			/**
274			* @param int $bytes
275			* @return int
276			*/
277			private function bytesInMegaBytes($bytes)
278			{
279			return ((int) ($bytes / 1048576)); //1048576 = 1024 * 1024
280			}
281
282			/**
283			* @param int $bytes
284			* @return int
285			*/
286			private function bytesInGigaBytes($bytes)
287			{
288			return ((int) ($bytes / 1073741824)); //1073741824 = 1024 * 1024 * 1024
289			}
290
291			/**
292			* @param int $kiloBytes
293			* @return int
294			*/
295			private function kiloBytesInBytes($kiloBytes)
296			{
297			return ((int) ($kiloBytes * 1024));
298			}
299
300			/**
301			* @param int $megaBytes
302			* @return int
303			*/
304			private function megaBytesInBytes($megaBytes)
305			{
306			return ((int) ($megaBytes * 1048576)); //1048576 = 1024 * 1024
307			}
308
309			/**
310			* @param int $gigaBytes
311			* @return int
312			*/
313			private function gigaBytesInBytes($gigaBytes)
314			{
315			return ((int) ($gigaBytes * 1073741824)); //1073741824 = 1024 * 1024 * 1024
316			}
317			}
318

bazzline / php_component_memory_limit_manager

MemoryLimitManager::getCurrentUsageInBytes() A last analyzed 2021-02-05 12:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MemoryLimitManager::getCurrentUsageInBytes() A
last analyzed 2021-02-05 12:19 UTC