CHECK MEMORY USAGE

Thankfully, no additional tools are required since PHP comes with native functions that will show the current memory usage. All we need to do is to use memory_get_usage() to show the current memory usage, and we can even pass in a true parameter to get the total system memory allocated to PHP.

";
echo "SCRIPT USAGE - " . memory_get_usage(). "
";

$foo = [];
for ($i=0; $i";

unset($foo);

echo memory_get_usage() . "
";
?>

PEAK MEMORY USAGE

But of course, it will be dumb for us to be adding “memory checkpoints” everywhere in the script… So thankfully, there is another memory_get_peak_usage() function that will tell us the peak memory usage.

";
echo "SCRIPT USAGE NOW - " . memory_get_usage(). "
";

$foo = [];
for ($i=0; $i";
?>

MEMORY USAGE PROFILING

If you want to have even more detailed information of the memory usage at specific points in the script, you are going to need to write your own monitoring script or use a tool – Xdebug is one that is capable of doing memory profiling.

PHP CONFIG FILE

If you are running into an “out-of-memory” problem, the laziest fix is to just raise the memory limits set in the php.ini config file.

memory_limit=256M

But please take note that if you change the php.ini file, it will affect the entire server. This can be potentially deadly when multiple scripts go berserk and cause a server crash. So if you want to change the limits in php.ini, please do so sparingly, and only after you have made sure the server can handle the load.

INLINE SET LIMIT

This is an alternative that I will recommend doing instead – 

This way, the memory limitation will only be raised for this particular script.

TO RAISE OR NOT TO RAISE?

Well, if you have to crunch out a report or do a transaction that requires a massive amount of memory, then so be it… But try to keep these heavy-duty tasks to the less busy hours, and adopt some coding techniques to optimize the performance of such scripts.

READ RESULTS FROM THE DATABASE LINE-BY-LINE

 PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES => false
  ]
) or die("Failed to connect to the database");

// SQL
$stmt = $pdo->prepare("SELECT * FROM `test`");
$stmt->execute();

// FETCH ALL AT ONCE - THIS IS WHAT SOME PEOPLE DO
// $results = $stmt->fetchAll();
// print_r($results);

// FOR MASSIVE SETS, FETCH LINE-BY-LINE INSTEAD.
while ($row = $stmt->fetch(PDO::FETCH_NAMED)) {
  print_r($row);
}

// CLOSE DATABASE CONNECTION
if ($stmt !== null) { $stmt = null; }
if ($pdo !== null) { $pdo = null; }

// PEAK MEMORY USED
echo "PEAK USAGE - " . memory_get_peak_usage() . "
";
?>

This is actually a rather common newbie mistake – Trying to pull out a million rows of data, and squeezing them into an array all-at-once… Of course, that will not end well. The smarter way to do it is to deal with the data row-by-row instead.

READ FILES LINE-BY-LINE

";
?>

Same old story, but trying to read a massive file into a single string; Read line-by-line instead.

COMPACT ALGORITHMS

 $varB) {
  $varC = $varA;
} else {
  $varC = $varB;
}
*/

// THIS IS BETTER
$varC = $varA > $varB ? $varA : $varB ;

// PEAK MEMORY USED
echo "PEAK USAGE - " . memory_get_peak_usage() . "
";
?>

Sometimes, we do stupid things and go around in circles… So please do review your scripts from time-to-time, and simplify it if you can. A less confusing streamlined code equals better performance.

CUT THE USELESS VARIABLES!

";
?>

Some of you code ninjas may laugh and brush this aside as “trivial”. How much memory can a single variable take? Well, the more useless variables you have floating around, the more memory the script consumes. Keep a hundred of such useless flags and variables in a huge project, and you will see the performance get hit hard.

MANUALLY REMOVE TEMPORARY FLAGS

Don’t need the temporary variables anymore? Clean them up.

DIRECT OUTPUT FROM DATABASE

 PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES => false
  ]
) or die("Failed to connect to the database");

// HTTP HEADERS
header('Content-Type: application/octet-stream');
header("Content-Transfer-Encoding: Binary"); 
header("Content-disposition: attachment; filename=\"export.csv\"");

// SQL
$stmt = $pdo->prepare("SELECT * FROM `test`");
$stmt->execute();

// FETCH & DIRECTLY OUTPUT
while ($row = $stmt->fetch(PDO::FETCH_NAMED)) {
  echo implode(",", $row) . "\r\n";
}

// CLOSE DATABASE CONNECTION
if ($stmt !== null) { $stmt = null; }
if ($pdo !== null) { $pdo = null; }
?>

When it comes to generating reports, some code ninjas may think – Fetch data from the database into an array first, then format that array, then output it. Well, there is actually a more effective way – That is to directly format and output as we read from the database.

REFERENCES

• PHP – Get memory usage
• PHP – Get peak memory usage
• Garbage collecting cycles in PHP

SOURCE CODE DOWNLOAD

Click here to download the source code, I have released it under the MIT license, so feel free to build on top of it or use it in your own project.
 

The post Php Memory Management – A Simple Guide appeared first on Code Boxx.