Benchmark::terminalWidth() - Code Metrics - Inspection of "wp 142" - alecrabbit/php-simple-profiler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 4a055d...f8787b )

by Alec

created 2019-04-03 15:47 UTC

Benchmark::terminalWidth() A

↳ Parent: Benchmark

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	0
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php declare(strict_types=1);

namespace AlecRabbit\Tools;

use AlecRabbit\Accessories\MemoryUsage;
use AlecRabbit\Accessories\Rewindable;
use AlecRabbit\ConsoleColour\Terminal;
use AlecRabbit\Tools\Contracts\BenchmarkInterface;
use AlecRabbit\Tools\Contracts\Strings;
use AlecRabbit\Tools\Internal\BenchmarkFunction;
use AlecRabbit\Tools\Reports\BenchmarkReport;
use AlecRabbit\Tools\Traits\BenchmarkFields;
use function AlecRabbit\typeOf;

class Benchmark extends Reportable implements BenchmarkInterface, Strings
{
    use BenchmarkFields;

    public const MIN_ITERATIONS = 100;
    public const DEFAULT_STEPS = 100;
    public const CLOSURE_NAME = 'λ';

    public const DEFAULT_SEPARATOR_CHAR = '─';
    public const DEFAULT_END_SEPARATOR_CHAR = '═';
    public const DEFAULT_TERMINAL_WIDTH = 80;
    public const WIDTH_COEFFICIENT = 0.8;

    /** @var int */
    protected $advanceSteps = self::DEFAULT_STEPS;
    /** @var Rewindable */
    protected $rewindable;
    /** @var int */
    protected $iterations;
    /** @var null|string */
    protected $comment;
    /** @var string|null */
    protected $humanReadableName;
    /** @var int */
    protected $totalIterations = 0;
    /** @var null|callable */
    protected $onStart;
    /** @var null|callable */
    protected $onAdvance;
    /** @var null|callable */
    protected $onFinish;
    /** @var int */
    protected $advanceStep = 0;
    /** @var \Closure */
    protected $iterationNumberGenerator;
    /** @var bool */
    protected $launched = false;
    /** @var int */
    protected $functionIndex = 1;
    /** @var bool */
    protected $silent = false;
    /** @var int */
    protected $terminalWidth = self::DEFAULT_TERMINAL_WIDTH;

    /**
     * Benchmark constructor.
     * @param null|int $iterations
     * @param null|bool $silent
     * @throws \Exception
     */
    public function __construct(?int $iterations = null, ?bool $silent = null)
    {
        $this->iterations = $this->refineIterations($iterations);
        $this->silent = $silent ?? $this->silent;

        $this->iterationNumberGenerator =
            static function (int $iterations, int $i = 1): \Generator {
                while ($i <= $iterations) {
                    yield $i++;
                }
            };

        $this->timer = new Timer(); // Timer to count benchmark process total time
        $this->initialize();
        $this->terminalWidth = $this->terminalWidth();
    }

    protected function refineIterations(?int $iterations): int
    {
        $iterations = $iterations ?? self::MIN_ITERATIONS;
        $this->assertIterations($iterations);
        return $iterations;
    }

    /**
     * @param int $iterations
     */
    protected function assertIterations(int $iterations): void
    {
        if ($iterations < self::MIN_ITERATIONS) {
            throw new \RuntimeException(
                '[' . __CLASS__ . '] Number of Iterations should be greater than ' . self::MIN_ITERATIONS . '.'
            );
        }
    }

    /**
     * Resets Benchmark object clear
     * @throws \Exception
     */
    protected function initialize(): void
    {
        unset($this->functions, $this->humanReadableName, $this->rewindable, $this->memoryUsageReport);

        $this->rewindable =
            new Rewindable(
                $this->iterationNumberGenerator,
                $this->iterations
            );
        $this->humanReadableName = null;
        $this->functions = [];
        $this->functionIndex = 1;
        $this->launched = false;
        $this->resetComment();
        $this->added = new SimpleCounter('added');
        $this->benchmarked = new SimpleCounter('benchmarked');
        $this->memoryUsageReport = MemoryUsage::report();
        $this->doneIterations = 0;
        $this->totalIterations = 0;
        $this->report = (new BenchmarkReport())->buildOn($this);
    }

    protected function resetComment(): void
    {
        $this->comment = null;
    }

    /**
     * @return int
     */
    protected function terminalWidth(): int
    {
        return (int)((new Terminal())->width() * static::WIDTH_COEFFICIENT);
    }

    /**
     * Resets Benchmark object clear. Returns divider string.
     * @param null|string $char
     * @return string
     * @throws \Exception
     */
    public function reset(?string $char = null): string
    {
        $this->initialize();
        return
            $this->sectionSeparator($char);
    }

    protected function sectionSeparator(?string $char): string
    {
        return str_repeat($char ?? static::DEFAULT_SEPARATOR_CHAR, self::DEFAULT_TERMINAL_WIDTH) . PHP_EOL . PHP_EOL;
    }

    /**
     * @param callable|null $onStart
     * @param callable|null $onAdvance
     * @param callable|null $onFinish
     * @return Benchmark
     */
    public function showProgressBy(
        callable $onStart = null,
        callable $onAdvance = null,
        callable $onFinish = null
    ): Benchmark {
        $this->onStart = $onStart;
        $this->onAdvance = $onAdvance;
        $this->onFinish = $onFinish;
        return $this;
    }

    /**
     * @param mixed $func
     * @param mixed ...$args
     * @throws \Exception
     */
    public function addFunction($func, ...$args): void
    {
        if ($this->isLaunched()) {
            throw new \RuntimeException('You should reset benchmark object before adding a new function.');
        }
        if (!\is_callable($func, false, $name)) {
            throw new \InvalidArgumentException(
                sprintf(
                    '\'%s\' is NOT callable. Function must be callable. Type of "%s" provided instead.',
                    $name,
                    typeOf($func)
                )
            );
        }
        $function =
            new BenchmarkFunction(
                $func,
                $this->refineName($func, $name),
                $this->functionIndex++,
                $args,
                $this->comment,
                $this->humanReadableName
            );
        $function->setShowReturns($this->isShowReturns());
        $this->functions[$function->enumeratedName()] = $function;
        $this->humanReadableName = null;
        $this->resetComment();
        $this->added->bump();
        $this->totalIterations += $this->iterations;
    }

    /**
     * @return bool
     */
    public function isLaunched(): bool
    {
        return $this->launched;
    }

    /**
     * @param callable $func
     * @param string $name
     * @return string
     */
    protected function refineName($func, $name): string
    {
        if ($func instanceof \Closure) {
            $name = self::CLOSURE_NAME;
        }
        return $name;
    }

    /**
     * @param string $comment
     * @return Benchmark
     */
    public function withComment(string $comment): self
    {
        $this->comment = $comment;
        return $this;
    }

    /**
     * @param string $name
     * @return Benchmark
     */
    public function useName(string $name): self
    {
        $this->humanReadableName = $name;
        return $this;
    }

    /**
     * @param bool $eol
     * @return string
     * @throws \Exception
     */
    public function stat(bool $eol = true): string
    {
        return
            sprintf(
                'Done in: %s%s%s',
                $this->getTimer()->elapsed(),
                PHP_EOL,
                (string)$this->memoryUsageReport
            ) .
            ($eol ? PHP_EOL : '');
    }

    /**
     * @return Benchmark
     */
    public function showReturns(): Benchmark
    {
        $this->setShowReturns(true);
        foreach ($this->functions as $function) {
            $function->setShowReturns($this->isShowReturns());
        }
        return $this;
    }

    /**
     * @param bool $showReturns
     */
    public function setShowReturns(bool $showReturns): void
    {
        $this->showReturns = $showReturns;
    }

    /** {@inheritdoc} */
    protected function meetConditions(): void
    {
        if ($this->isNotLaunched()) {
            $this->run();
        }
    }

    /**
     * @return bool
     */
    public function isNotLaunched(): bool
    {
        return !$this->isLaunched();
    }

    /**
     * Launch benchmarking
     */
    public function run(): self
    {
        $this->displayComment();
        $this->launched = true;
        if ($this->onStart) {
            ($this->onStart)();
        }
        $this->execute();
        if ($this->onFinish) {
            ($this->onFinish)();
        }
        $this->doneIterationsCombined += $this->doneIterations;
        return $this;
    }

    protected function displayComment(): void
    {
        if (!$this->silent && null !== $this->comment) {
            $this->showComment($this->comment);
            $this->resetComment();
        }
    }

    protected function showComment(string $comment = ''): void
    {
        echo $comment . PHP_EOL;
    }

    /**
     * Benchmarking
     */
    protected function execute(): void
    {
        /** @var  BenchmarkFunction $f */
        foreach ($this->functions as $f) {
            if (!$f->execute()) {
                $this->totalIterations -= $this->iterations;
                continue;
            }
            $this->advanceStep = (int)($this->totalIterations / $this->advanceSteps + 1);
            $this->bench($f);
            $this->benchmarked->bump();
        }
    }

    /**
     * @param BenchmarkFunction $f
     */
    protected function bench(BenchmarkFunction $f): void
    {
        $timer = $f->getTimer();
        $function = $f->getCallable();
        $args = $f->getArgs();
        foreach ($this->rewindable as $iteration) {
            $start = $timer->current();
            /** @noinspection DisconnectedForeachInstructionInspection */
            $function(...$args);
            $stop = $timer->current();
            $timer->bounds($start, $stop, $iteration);
            /** @noinspection DisconnectedForeachInstructionInspection */
            $this->progress();
        }
    }

    protected function progress(): void
    {
        $this->doneIterations++;
        if ($this->onAdvance && 0 === $this->doneIterations % $this->advanceStep) {
            ($this->onAdvance)();
        }
    }
}


1		<?php declare(strict_types=1);
2
3		namespace AlecRabbit\Tools;
4
5		use AlecRabbit\Accessories\MemoryUsage;
6		use AlecRabbit\Accessories\Rewindable;
7		use AlecRabbit\ConsoleColour\Terminal;
8		use AlecRabbit\Tools\Contracts\BenchmarkInterface;
9		use AlecRabbit\Tools\Contracts\Strings;
10		use AlecRabbit\Tools\Internal\BenchmarkFunction;
11		use AlecRabbit\Tools\Reports\BenchmarkReport;
12		use AlecRabbit\Tools\Traits\BenchmarkFields;
13		use function AlecRabbit\typeOf;
14
15		class Benchmark extends Reportable implements BenchmarkInterface, Strings
16		{
17		use BenchmarkFields;
18
19		public const MIN_ITERATIONS = 100;
20		public const DEFAULT_STEPS = 100;
21		public const CLOSURE_NAME = 'λ';
22
23		public const DEFAULT_SEPARATOR_CHAR = '─';
24		public const DEFAULT_END_SEPARATOR_CHAR = '═';
25		public const DEFAULT_TERMINAL_WIDTH = 80;
26		public const WIDTH_COEFFICIENT = 0.8;
27
28		/** @var int */
29		protected $advanceSteps = self::DEFAULT_STEPS;
30		/** @var Rewindable */
31		protected $rewindable;
32		/** @var int */
33		protected $iterations;
34		/** @var null\|string */
35		protected $comment;
36		/** @var string\|null */
37		protected $humanReadableName;
38		/** @var int */
39		protected $totalIterations = 0;
40		/** @var null\|callable */
41		protected $onStart;
42		/** @var null\|callable */
43		protected $onAdvance;
44		/** @var null\|callable */
45		protected $onFinish;
46		/** @var int */
47		protected $advanceStep = 0;
48		/** @var \Closure */
49		protected $iterationNumberGenerator;
50		/** @var bool */
51		protected $launched = false;
52		/** @var int */
53		protected $functionIndex = 1;
54		/** @var bool */
55		protected $silent = false;
56		/** @var int */
57	20	protected $terminalWidth = self::DEFAULT_TERMINAL_WIDTH;
58
59	20	/**
60	20	* Benchmark constructor.
61		* @param null\|int $iterations
62	20	* @param null\|bool $silent
63		* @throws \Exception
64	16	*/
65	16	public function __construct(?int $iterations = null, ?bool $silent = null)
66		{
67	16	$this->iterations = $this->refineIterations($iterations);
68		$this->silent = $silent ?? $this->silent;
69	20
70	20	$this->iterationNumberGenerator =
71	20	static function (int $iterations, int $i = 1): \Generator {
72		while ($i <= $iterations) {
73	20	yield $i++;
74		}
75	20	};
76	20
77	20	$this->timer = new Timer(); // Timer to count benchmark process total time
78		$this->initialize();
79		$this->terminalWidth = $this->terminalWidth();
80		}
81
82		protected function refineIterations(?int $iterations): int
83	20	{
84		$iterations = $iterations ?? self::MIN_ITERATIONS;
85	20	$this->assertIterations($iterations);
86	1	return $iterations;
87	1	}
88
89		/**
90	20	* @param int $iterations
91		*/
92		protected function assertIterations(int $iterations): void
93		{
94		if ($iterations < self::MIN_ITERATIONS) {
95		throw new \RuntimeException(
96	20	'[' . __CLASS__ . '] Number of Iterations should be greater than ' . self::MIN_ITERATIONS . '.'
97		);
98	20	}
99		}
100	20
101	20	/**
102	20	* Resets Benchmark object clear
103	20	* @throws \Exception
104		*/
105	20	protected function initialize(): void
106	20	{
107	20	unset($this->functions, $this->humanReadableName, $this->rewindable, $this->memoryUsageReport);
108	20
109	20	$this->rewindable =
110	20	new Rewindable(
111	20	$this->iterationNumberGenerator,
112	20	$this->iterations
113	20	);
114	20	$this->humanReadableName = null;
115	20	$this->functions = [];
116	20	$this->functionIndex = 1;
117		$this->launched = false;
118	20	$this->resetComment();
119		$this->added = new SimpleCounter('added');
120	20	$this->benchmarked = new SimpleCounter('benchmarked');
121	20	$this->memoryUsageReport = MemoryUsage::report();
122		$this->doneIterations = 0;
123		$this->totalIterations = 0;
124		$this->report = (new BenchmarkReport())->buildOn($this);
125		}
126
127	2	protected function resetComment(): void
128		{
129	2	$this->comment = null;
130	2	}
131
132		/**
133		* @return int
134		*/
135		protected function terminalWidth(): int
136		{
137		return (int)((new Terminal())->width() * static::WIDTH_COEFFICIENT);
138	4	}
139
140		/**
141		* Resets Benchmark object clear. Returns divider string.
142		* @param null\|string $char
143	4	* @return string
144	4	* @throws \Exception
145	4	*/
146	4	public function reset(?string $char = null): string
147		{
148		$this->initialize();
149		return
150		$this->sectionSeparator($char);
151		}
152
153		protected function sectionSeparator(?string $char): string
154	17	{
155		return str_repeat($char ?? static::DEFAULT_SEPARATOR_CHAR, self::DEFAULT_TERMINAL_WIDTH) . PHP_EOL . PHP_EOL;
156	17	}
157	1
158	1	/**
159	1	* @param callable\|null $onStart
160		* @param callable\|null $onAdvance
161	1	* @param callable\|null $onFinish
162		* @return Benchmark
163		*/
164		public function showProgressBy(
165		callable $onStart = null,
166	16	callable $onAdvance = null,
167	16	callable $onFinish = null
168	16	): Benchmark {
169	16	$this->onStart = $onStart;
170		$this->onAdvance = $onAdvance;
171	16	$this->onFinish = $onFinish;
172	16	return $this;
173		}
174	16
175	16	/**
176	16	* @param mixed $func
177	16	* @param mixed ...$args
178	16	* @throws \Exception
179	16	*/
180	16	public function addFunction($func, ...$args): void
181		{
182		if ($this->isLaunched()) {
183		throw new \RuntimeException('You should reset benchmark object before adding a new function.');
184		}
185		if (!\is_callable($func, false, $name)) {
186		throw new \InvalidArgumentException(
187	16	sprintf(
188		'\'%s\' is NOT callable. Function must be callable. Type of "%s" provided instead.',
189	16	$name,
190	16	typeOf($func)
191		)
192	16	);
193		}
194		$function =
195		new BenchmarkFunction(
196		$func,
197		$this->refineName($func, $name),
198		$this->functionIndex++,
199	6	$args,
200		$this->comment,
201	6	$this->humanReadableName
202	6	);
203		$function->setShowReturns($this->isShowReturns());
204		$this->functions[$function->enumeratedName()] = $function;
205		$this->humanReadableName = null;
206		$this->resetComment();
207		$this->added->bump();
208		$this->totalIterations += $this->iterations;
209	7	}
210
211	7	/**
212	7	* @return bool
213		*/
214		public function isLaunched(): bool
215		{
216		return $this->launched;
217		}
218
219	4	/**
220		* @param callable $func
221		* @param string $name
222	4	* @return string
223	4	*/
224	4	protected function refineName($func, $name): string
225	4	{
226	4	if ($func instanceof \Closure) {
227		$name = self::CLOSURE_NAME;
228		}
229		return $name;
230		}
231
232		/**
233	1	* @param string $comment
234		* @return Benchmark
235	1	*/
236	1	public function withComment(string $comment): self
237	1	{
238		$this->comment = $comment;
239	1	return $this;
240		}
241
242		/**
243		* @param string $name
244		* @return Benchmark
245	1	*/
246		public function useName(string $name): self
247	1	{
248	1	$this->humanReadableName = $name;
249		return $this;
250		}
251	15
252		/**
253	15	* @param bool $eol
254	10	* @return string
255		* @throws \Exception
256	15	*/
257		public function stat(bool $eol = true): string
258		{
259		return
260		sprintf(
261	15	'Done in: %s%s%s',
262		$this->getTimer()->elapsed(),
263	15	PHP_EOL,
264		(string)$this->memoryUsageReport
265		) .
266		($eol ? PHP_EOL : '');
267		}
268
269	15	/**
270		* @return Benchmark
271	15	*/
272		public function showReturns(): Benchmark
273		{
274		$this->setShowReturns(true);
275		foreach ($this->functions as $function) {
276		$function->setShowReturns($this->isShowReturns());
277	17	}
278		return $this;
279	17	}
280	17
281	17	/**
282	3	* @param bool $showReturns
283		*/
284	17	public function setShowReturns(bool $showReturns): void
285	17	{
286	4	$this->showReturns = $showReturns;
287		}
288	17
289	17	/** {@inheritdoc} */
290		protected function meetConditions(): void
291		{
292	17	if ($this->isNotLaunched()) {
293		$this->run();
294	17	}
295		}
296
297		/**
298	17	* @return bool
299		*/
300		public function isNotLaunched(): bool
301		{
302		return !$this->isLaunched();
303		}
304
305		/**
306		* Launch benchmarking
307		*/
308	17	public function run(): self
309		{
310		$this->displayComment();
311	17	$this->launched = true;
312	16	if ($this->onStart) {
313	7	($this->onStart)();
314	7	}
315		$this->execute();
316	16	if ($this->onFinish) {
317	16	($this->onFinish)();
318	16	}
319		$this->doneIterationsCombined += $this->doneIterations;
320	17	return $this;
321		}
322
323		protected function displayComment(): void
324		{
325	16	if (!$this->silent && null !== $this->comment) {
326		$this->showComment($this->comment);
327	16	$this->resetComment();
328	16	}
329	16	}
330	16
331	16	protected function showComment(string $comment = ''): void
332		{
333	16	echo $comment . PHP_EOL;
334	16	}
335	16
336		/**
337	16	* Benchmarking
338		*/
339	16	protected function execute(): void
340		{
341	16	/** @var BenchmarkFunction $f */
342		foreach ($this->functions as $f) {
343	16	if (!$f->execute()) {
344	16	$this->totalIterations -= $this->iterations;
345	4	continue;
346		}
347	16	$this->advanceStep = (int)($this->totalIterations / $this->advanceSteps + 1);
348		$this->bench($f);
349		$this->benchmarked->bump();
350		}
351		}
352
353		/**
354		* @param BenchmarkFunction $f
355		*/
356		protected function bench(BenchmarkFunction $f): void
357		{
358		$timer = $f->getTimer();
359		$function = $f->getCallable();
360		$args = $f->getArgs();
361		foreach ($this->rewindable as $iteration) {
362		$start = $timer->current();
363		/** @noinspection DisconnectedForeachInstructionInspection */
364		$function(...$args);
365		$stop = $timer->current();
366		$timer->bounds($start, $stop, $iteration);
367		/** @noinspection DisconnectedForeachInstructionInspection */
368		$this->progress();
369		}
370		}
371
372		protected function progress(): void
373		{
374		$this->doneIterations++;
375		if ($this->onAdvance && 0 === $this->doneIterations % $this->advanceStep) {
376		($this->onAdvance)();
377		}
378		}
379		}
380

alecrabbit / php-simple-profiler

Push — develop ( 4a055d...f8787b )

Benchmark::terminalWidth() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like