DEV Community: Alex

PHP Profiling: From Problem to Solution (with Metrics)

Alex — Sat, 16 Aug 2025 12:09:39 +0000

Initial Scenario

We have a script that processes 200,000 email addresses.
It was expected to run fast, but the measurement showed 12.8 seconds.
We need to identify what slows it down and speed it up.

Step 1. Capture a Profile

Xdebug config (CLI):

zend_extension=xdebug
xdebug.mode=profile
xdebug.output_dir=/tmp/xdebug
xdebug.start_with_request=yes

Run:

php import_emails.php

A file cachegrind.out.* appears in /tmp/xdebug.
Open it with KCachegrind (Linux) or QCachegrind (macOS/Windows).

Step 2. Read the Profile

The profile shows:

array_unique — 42% Self time.
filter_var — 35% Inclusive time.
Lots of unnecessary string allocations due to repeated transformations.

Step 3. Optimize Step‑by‑Step

PHP Email Import Optimization — Before vs After

1) Remove `array_unique`

Before (expensive: stores all emails, then deduplicates):

$emails = [];

foreach ($rows as $row) {
    $email = $row['email'];
    // ... other logic ...
    $emails[] = $email; // duplicates pile up
}

$emails = array_unique($emails); // heavy on time & memory

After (instant dedup with a set-like map):

$set = [];

foreach ($rows as $row) {
    $email = $row['email'];
    if (!isset($set[$email])) { $set[$email] = true; }
}

Metric: 12.8 → 8.5 s, memory: 78 → 56 MB.

2) Fewer string transformations

Before (repeated/extra transformations):

foreach ($rows as $row) {
    $email = $row['email'] ?? '';
    $email = trim($email);
    $email = strtolower($email);

    // later again (duplicated work):
    $email = trim($email);
    $email = strtolower($email);
    if ($email === '') continue;
}

After (do it once, in the right order):

foreach ($rows as $row) {
    $email = trim($row['email'] ?? '');
    if ($email === '') continue;
    $email = strtolower($email);
    // proceed with $email
}

Metric: 8.5 → 5.4 s, memory: 56 → 42 MB.

3) Lightweight email validation (optional)

Before (heavier checks like full RFC/IDN):

foreach ($rows as $row) {
    $email = strtolower(trim($row['email'] ?? ''));
    if ($email === '') continue;

    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) continue;
    // ...
}

After (simple format check):

foreach ($rows as $row) {
    $email = strtolower(trim($row['email'] ?? ''));
    if ($email === '') continue;

    if (!preg_match('/^[^\s@]+@[^\s@]+\.[^\s@]+$/', $email)) continue;
    // ...
}

Metric: 5.4 → 2.1 s, memory: 42 → 40 MB.

Keep filter_var/IDN if you need strict RFC compliance or internationalized domains.

Results

Step	Time	Memory	Gain
Before	12.8s	78 MB	—
After step 1	8.5s	56 MB	−4.3s
After step 2	5.4s	42 MB	−3.1s
After step 3	2.1s	40 MB	−3.3s

Why This Matters

Without profiling we’d waste time optimizing blindly.
With the profile we see exactly where resources are spent and fix only that.
Result — 6× faster and 2× less memory.
(the exact numbers may vary depending on your machine)

Five Golden Rules of Profiling

Measure, don’t speculate.
Compare apples to apples (same data, same setup).
Hunt down the biggest time-wasters first.
Fix one thing at a time.
Trust metrics, not intuition.

Repository

All the code examples used in this article (before/after scripts) are available here: https://github.com/phpner/php-profiling-example

Conclusion

Profiling gives a clear picture of what slows your code.

Lazy Evaluation in PHP: Real‑World Memory Savings with Generators

Alex — Fri, 08 Aug 2025 16:33:47 +0000

Introduction

Have you ever tried to load a CSV file with a million rows into memory and ended up with something like this?

PHP Fatal error:  Allowed memory size of 134217728 bytes exhausted

Even with a higher memory_limit, the entire dataset still sits in memory while you process it line by line.

The solution? Lazy evaluation — a technique where data is generated and processed only when it's actually needed.

In PHP, you can achieve this in two ways: with generators (yield) and via the Iterator API. Let’s explore both.

What Is Lazy Evaluation?

Normally, when you create an array, PHP loads all elements into memory at once:

function getNumbersArray(int $count): array {
    $result = [];
    for ($i = 1; $i <= $count; $i++) {
        $result[] = $i;
    }
    return $result;
}

foreach (getNumbersArray(5) as $number) {
    echo $number . PHP_EOL;
}

Here, the entire array [1, 2, 3, 4, 5] is stored in memory.

Now let’s try a lazy approach:

function getNumbersGenerator(int $count): Generator {
    for ($i = 1; $i <= $count; $i++) {
        yield $i;
    }
}

foreach (getNumbersGenerator(5) as $number) {
    echo $number . PHP_EOL;
}

📌 The key difference: the generator doesn't store everything — it yields one element at a time, as foreach requests it.

Reading a Huge CSV Without Pain

Imagine you have a data.csv file that’s 2 GB in size. If you try to load it with file() or fgetcsv() into an array, you'll likely run out of memory.

But with a generator, it's easy:

function readCsv(string $filename): Generator {
    $handle = fopen($filename, 'r');
    if ($handle === false) {
        throw new RuntimeException("Cannot open file $filename");
    }

    while (($row = fgetcsv($handle)) !== false) {
        yield $row;
    }

    fclose($handle);
}

foreach (readCsv('data.csv') as $row) {
    // Process the row
    // For example: echo implode(', ', $row) . PHP_EOL;
}

📊 Memory usage: even with a 2 GB CSV, only one row is stored in memory at a time, so usage stays in the kilobytes.

Benchmark: Array vs Generator

$startMemory = memory_get_usage();

$array = range(1, 1_000_000); // creates an array with a million numbers

echo "Array: " . (memory_get_usage() - $startMemory) / 1024 / 1024 . " MB
";

unset($array);

$startMemory = memory_get_usage();

function bigGenerator(): Generator {
    for ($i = 1; $i <= 1_000_000; $i++) {
        yield $i;
    }
}

foreach (bigGenerator() as $n) {
    // Just iterate
}

echo "Generator: " . (memory_get_usage() - $startMemory) / 1024 / 1024 . " MB
";

On my machine:

Array: 120 MB
Generator: 0.5 MB

The Iterator API

Generators are quick and simple. But sometimes you need more control — preserving state, managing custom keys, or switching data sources dynamically.

That's where the Iterator API comes in.

Example: Custom Iterator

class RangeIterator implements Iterator {
    private int $start;
    private int $end;
    private int $current;

    public function __construct(int $start, int $end) {
        $this->start = $start;
        $this->end = $end;
        $this->current = $start;
    }

    public function current(): int {
        return $this->current;
    }

    public function key(): int {
        return $this->current;
    }

    public function next(): void {
        $this->current++;
    }

    public function rewind(): void {
        $this->current = $this->start;
    }

    public function valid(): bool {
        return $this->current <= $this->end;
    }
}

foreach (new RangeIterator(1, 5) as $num) {
    echo $num . PHP_EOL;
}

When to Use What?

Scenario	Recommended Approach
Need to stream data on demand	Generator
Need complex logic or internal state	Iterator API
Reading large files or DB streams	Generator
Multiple iterations with preserved state	Iterator API

Real Production Case

We were parsing an automotive sales API that returned hundreds of thousands of records.

Originally, we loaded everything into an array — the script used 1–2 GB of memory.

After switching to a generator:

function fetchCars(): Generator {
    $page = 1;
    do {
        $data = apiRequest('cars', ['page' => $page]);
        foreach ($data['items'] as $car) {
            yield $car;
        }
        $page++;
    } while (!empty($data['items']));
}

📉 Memory usage dropped from 2 GB to just 10 MB — with no noticeable change in execution time.

🔍 For Geeks: How Generators Work Under the Hood

1. A Generator Is an Object

In PHP, a generator is an object of class Generator, implementing both Iterator and Traversable.

It can:

store function state;
pause execution at yield;
resume from the same spot.

2. Execution Flow

Calling the generator function doesn’t run the code — it returns a Generator object.
The first foreach or current() call executes until the first yield.
Each yield pauses execution and returns a value.
next() resumes from the paused point.
When the function ends, the generator is marked as completed.

3. Zend Engine Internals

If you compile a generator function using VLD (Vulcan Logic Disassembler), each yield corresponds to an instruction that:

saves the call stack;
stores variable context;
yields control back to the caller.

4. Compared to Arrays

Arrays store all elements in memory at once.
Generators hold only the current element (zval) and overwrite it with each step.
You can process a million elements using just a few hundred kilobytes.

5. Infinite Generator Example

function counter(): Generator {
    $i = 0;
    while (true) {
        yield $i++;
    }
}

foreach (counter() as $num) {
    if ($num > 5) break;
    echo $num . PHP_EOL;
}

You couldn’t do this with an array — memory would run out quickly.

🔗 Source Code

You can try everything yourself — the code used in this article is open source:

👉 github.com/phpner/phpner-php-lazy-evaluation-demo

It includes:

CSV benchmark: array (eager) vs generator (lazy)
NDJSON stream simulation
Memory and time profiling
CLI-friendly tools
Sample data generator
PHPUnit tests

📊 Benchmark results (1,000,001 rows)

Method	Time	Memory used	Peak diff	Rows
Array (eager)	1.401s	120 B	395.92 MB	1,000,001
Generator	1.012s	0 B	0.00 MB	1,000,001

These results show that lazy generators can significantly reduce memory usage when processing large datasets like CSVs.

🖼️ Visual results

📈 Peak memory usage:

📉 Execution time:

Feel free to fork the repo, try the benchmarks, or adapt it to your own data processing tasks!

Conclusion

✅ Generators and the Iterator API are must-haves for modern PHP development.

They let you process millions of records without running out of memory.

Use generators for simple streaming logic, and Iterator API when you need more control.

💬 Do you use generators in production? Share your use cases in the comments!

The Hidden Path to Computers — Through the Lens of “Code” by Charles Petzold

Alex — Fri, 08 Aug 2025 08:51:48 +0000

📖 About the Book

Charles Petzold is an author who managed to explain the complex world of computer technology through compelling storytelling. His book Code: The Hidden Language of Computer Hardware and Software takes us on a journey from the earliest methods of communication to the modern digital computer — without dry technical jargon, but with real-world examples, metaphors, and historical facts.

"Computers are not magic. They are the result of a long human journey that began long before the invention of electronics."

1. How Humans Began to Communicate Information

Petzold begins by showing that people have always had the need to send messages across distances. At first, this meant using signal fires on hills, drums in the jungle, or flags on ships. Each of these methods had limits: in speed, distance, or the number of symbols available.

Eventually, we arrive at Morse code.

2. Morse Code: The First “Zeros” and “Ones”

Samuel Morse invented a system of short (dot) and long (dash) electrical signals. It was the first practical digital code — not literally zeros and ones, but conceptually very close: only two distinct signals used in combination to represent any letter or number.

📌 Key features:

Efficiency: The most common letters (like E and T) were assigned the shortest codes.
Messages were sent by completing or breaking an electrical circuit.
Telegraph operators could hear the code in real time and interpret it by ear.

“Morse code was the first system to show that any kind of information could be transmitted using just two types of signals.”

3. From Signals to Electricity

The telegraph was revolutionary for communication, but it only transmitted, not processed, information.

The next leap came with the realization that electric signals could do work — they could control machines, and ultimately, perform logic.

Here, Petzold introduces the relay — a simple switch that opens or closes in response to electrical current. It too has two states, which fits naturally into binary logic.

4. The Binary Number System

For a machine to "understand" anything, it must be able to represent numbers and instructions.

The binary system (0 and 1) turned out to be ideal:

0 = off
1 = on

Historically, the binary number system was described by Gottfried Wilhelm Leibniz in the 17th century. But with the invention of electrical switches, it became practically useful.

5. Logic Gates and Circuits

Petzold shows that using relays, you can build basic logic gates:

AND
OR
NOT

By combining these, you can construct any computation. This leads to the central insight:

A computer is essentially a massive network of binary switches arranged in logical combinations.

6. From Mechanical Devices to Electronics

Before relays, there were mechanical calculators — like Charles Babbage’s Analytical Engine. But they were slow, bulky, and unreliable.

Eventually, vacuum tubes and transistors replaced relays, making computations faster and more compact.

7. Encoding Text, Images, and Sound

Once you can handle numbers, you can represent anything:

Text: through ASCII, where each letter has a unique binary number.
Images: grids of black/white pixels, each encoded as 0 or 1.
Sound: sequences of numbers representing waveform amplitudes.

This showed that all information — visual, audio, textual — could be reduced to binary.

8. Programs and Memory

After machines could store and manipulate binary data, they needed instructions — programs.

Memory began to store both data and instructions, which led to the concept of the Von Neumann architecture, where program and data coexist in the same memory space.

9. The Big Realization

By the end of the book, the reader understands:

A computer is not a magical box. It’s a machine built from simple components (relays, switches, transistors) that operate on binary logic.
Complexity arises from the clever arrangement of simple building blocks.

“A computer is nothing more than a very fast and very obedient idiot doing exactly what we tell it to.”

🎯 Why This Book Is Valuable

It gives you an intuitive understanding of how computers work — without formulas.
It shows a clear historical progression: signal fires → Morse code → relays → transistors → processors
After reading it, you begin to see technology as a chain of brilliant simplifications, rather than complexity.

DEV Community: Alex

PHP Profiling: From Problem to Solution (with Metrics)

Initial Scenario

Step 1. Capture a Profile

Step 2. Read the Profile

Step 3. Optimize Step‑by‑Step

1) Remove array_unique

2) Fewer string transformations

3) Lightweight email validation (optional)

Results

Why This Matters

Five Golden Rules of Profiling

Repository

Conclusion

Lazy Evaluation in PHP: Real‑World Memory Savings with Generators

Introduction

What Is Lazy Evaluation?

Reading a Huge CSV Without Pain

Benchmark: Array vs Generator

The Iterator API

Example: Custom Iterator

When to Use What?

Real Production Case

🔍 For Geeks: How Generators Work Under the Hood

1. A Generator Is an Object

2. Execution Flow

3. Zend Engine Internals

4. Compared to Arrays

5. Infinite Generator Example

🔗 Source Code

📊 Benchmark results (1,000,001 rows)

🖼️ Visual results

Conclusion

The Hidden Path to Computers — Through the Lens of “Code” by Charles Petzold

📖 About the Book

1. How Humans Began to Communicate Information

2. Morse Code: The First “Zeros” and “Ones”

📌 Key features:

3. From Signals to Electricity

4. The Binary Number System

5. Logic Gates and Circuits

6. From Mechanical Devices to Electronics

7. Encoding Text, Images, and Sound

8. Programs and Memory

9. The Big Realization

🎯 Why This Book Is Valuable

1) Remove `array_unique`