{"id":7243,"date":"2024-12-05T09:50:32","date_gmt":"2024-12-05T09:50:32","guid":{"rendered":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/haydenjames.io\/?p=7243"},"modified":"2025-02-04T15:47:20","modified_gmt":"2025-02-04T15:47:20","slug":"understanding-php-memory_limit","status":"publish","type":"post","link":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/understanding-php-memory_limit\/","title":{"rendered":"PHP memory_limit \u2013 understanding and increasing"},"content":{"rendered":"

PHP’s memory_limit is per-script<\/em>, just as a highway’s speed limit is per-vehicle<\/em>. For example, although PHP\u2019s memory limit may be set to 1GB, that does not mean that scripts will pile up to use that 1 GB. Let\u2019s take a closer look at understanding PHP\u2019s memory_limit setting.<\/p>

\"Linux<\/a><\/div>
\r\n\tAdvertisement\r\n<\/div><\/div>\n

PHP memory_limit is a per-script setting<\/strong><\/h2>\n

PHP.net’s documentation puts it this way:<\/p>\n

This sets the maximum amount of memory in bytes that a script<\/strong> is allowed to allocate. This helps prevent poorly written scripts for eating up all available memory on a server...<\/pre>\n
Source: https:\/\/round-lake.dustinice.workers.dev:443\/http\/php.net\/manual\/en\/ini.core.php#ini.memory-limit<\/a><\/p>\n
Unlike, say, MySQL’s innodb_buffer_pool settings, the PHP memory_limit setting is not<\/strong> a storage space where multiple PHP scripts pool from or grow within. Rather, it’s a\u00a0per-script limit<\/strong>. PHP memory_limit is the maximum amount of server memory a\u00a0single<\/strong>\u00a0PHP script is allowed to consume. When blocked, the resulting error output looks something like this:<\/p>\n
Fatal error: Allowed memory size of x bytes exhausted (tried to allocate x bytes) in \/path\/to\/php\/script<\/pre>\n
Or like this:<\/p>\n
PHP Fatal error: Out of memory (allocated x) (tried to allocate x bytes) in \/path\/to\/php\/script<\/pre>\n
So, for example, if two or more scripts are requested simultaneously, each is completely independent of the other. They do not share the memory_limit setting. Remember, PHP is not designed for and does not support multithreading<\/a>. Thus, if five PHP scripts simultaneously use 100 MB each<\/em>, that would consume 500 MB of total PHP memory usage on the server. Yet, in this scenario, a PHP memory_limit setting of ‘256M’ per script would not be hit.<\/p>\n
\"PHP
\nPHP memory_limit is per-script, just as a highway’s speed limit is per-vehicle.<\/em><\/p>\n
That said, for scripts that request other PHP scripts inline using require, include, or include_once, this limit is then inherited and shared by all included scripts that are dependent on the parent script.<\/p>\n
“The include statement takes all the text\/code\/markup that exists in the specified file and copies it into the file that uses the include statement. The require() function is identical to include(), except that it handles errors differently. If an error occurs, the include() function generates a warning, but the script will continue execution. The require() generates a fatal error, and the script will stop.” – W3schools<\/a>.<\/em><\/span><\/p>\n
“The require_once() statement is identical to require() except PHP will check if the file has already been included, and if so, not include (require) it again.” – php.net<\/a><\/em><\/span><\/p>\n
Now, regarding the original example mentioned at the outset. A lower setting of 256M is always better because if PHP scripts are trying to use more than 256M, those scripts would now return memory limit exceeded errors. In the above issue, that was not the case, so regardless of the 256M or 1G memory_limit setting, it only comes into play if there are inefficient scripts.<\/p>\n
Fortunately, the PHP memory_limit setting will block inefficient code, alerting you to optimize your code. Until fixed, you may want to temporarily increase PHP memory_limit to avoid your web application becoming unusable due to PHP out-of-memory errors.<\/p>\n
If you don’t have available memory on your server, you’ll sometimes be faced with deciding whether to increase PHP memory_limit to meet the requirements of scripts or to optimize your code. It would be best if you always optimized as the preferred option when possible. Also, you can increase PHP’s memory limit for specific websites. One method would be to place a php.ini file in the site’s webroot. You can even set the limit for specific scriptname.php. For example, using ini_set(‘memory_limit’,’256MB’)<\/a>.<\/p>\n
How to increase PHP\u00a0memory_limit<\/strong><\/h2>\n
To increase the PHP memory limit setting, edit your PHP.ini file. Increase the default value (example: Maximum amount of memory a script may consume = 256 MB) of the PHP memory limit<\/strong> line in php.ini.<\/p>\n
memory_limit = 2048M<\/pre>\n
Alternatively, you can edit your .htaccess file (Not recommended. See: Apache Performance: Disable .htaccess<\/a>)<\/p>\n
php_value memory_limit 2048M<\/pre>\n
If you don’t have access to these files or the experience to make this change, you can contact your web host and ask them to increase your PHP memory limit.<\/p>\n
Conclusion<\/h2>\n
While your PHP configuration might boast a generous memory limit, it’s important to grasp that individual scripts don’t accumulate memory like a shared pool. Instead, each script operates within its allocated memory boundary.<\/p>\n
This per-script nature ensures that one script’s inefficiency won’t hinder others. If multiple scripts are executed simultaneously, they remain independent and won’t collectively breach the memory limit. However, when scripts call upon other scripts using ‘require’ or ‘include,’ the parent script’s memory limit extends to its dependencies.<\/p>\n
The PHP memory_limit setting serves as a guardian against runaway scripts, throwing ‘memory limit exceeded’ errors when needed. It’s a valuable tool for identifying and rectifying inefficient code. When facing such errors, it’s wise to temporarily increase the memory limit, allowing your web application to remain functional while you optimize your code.<\/p>
\r\n  \"ManageEngine\r\n<\/a><\/div>
\r\n\tAdvertisement\r\n<\/div><\/div>\n
In conclusion, PHP memory_limit is a crucial element in maintaining the performance<\/a> and reliability<\/a> of your web applications. By comprehending its per-script nature and using it judiciously, you can ensure that your websites run smoothly and efficiently, providing a seamless experience for users and developers alike.<\/p>\n
 <\/p>\n
Originally published: September 18th, 2017 | <\/em>Last updated: December 5th, 2024.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
PHP’s memory_limit is per-script, just as a highway’s speed limit is per-vehicle. For example, although PHP\u2019s memory limit may be set to 1GB, that does not mean that scripts will pile up to use that 1 GB. Let\u2019s take a closer look at understanding PHP\u2019s memory_limit setting. PHP memory_limit is a per-script setting PHP.net’s documentation […]<\/p>\n","protected":false},"author":6,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"publish_to_discourse":"0","publish_post_category":"54","wpdc_auto_publish_overridden":"1","wpdc_topic_tags":"","wpdc_pin_topic":"","wpdc_pin_until":"","discourse_post_id":"4256","discourse_permalink":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxcommunity.io\/t\/php-memory-limit-understanding-and-increasing\/2034","wpdc_publishing_response":"","wpdc_publishing_error":"","footnotes":""},"categories":[1,11],"tags":[54,45,92],"class_list":["post-7243","post","type-post","status-publish","format-standard","hentry","category-articles","category-linux","tag-memory","tag-performance","tag-php"],"_links":{"self":[{"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/posts\/7243","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/comments?post=7243"}],"version-history":[{"count":4,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/posts\/7243\/revisions"}],"predecessor-version":[{"id":19750,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/posts\/7243\/revisions\/19750"}],"wp:attachment":[{"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/media?parent=7243"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/categories?post=7243"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/linuxblog.io\/wp-json\/wp\/v2\/tags?post=7243"}],"curies":[{"name":"wp","href":"https:\/\/round-lake.dustinice.workers.dev:443\/https\/api.w.org\/{rel}","templated":true}]}}