Errore irreversibile: dimensione della memoria consentita di 134217728 byte esauriti (CodeIgniter + XML-RPC)

Ho un sacco di sistemi client point of sale (POS) che inviano periodicamente nuovi dati di vendita a un database centralizzato, che memorizza i dati in un grande database per la generazione di report.

Il POS client si basa su PHPPOS e ho implementato un modulo che utilizza la libreria XML-RPC standard per inviare i dati di vendita al servizio. Il sistema server è basato su CodeIgniter e utilizza le librerie XML-RPC e XML-RPCS per il componente webservice. Ogni volta che invio molti dati sulle vendite (fino a 50 righe dalla tabella delle vendite e singole righe dagli articoli sales relativi a ciascun articolo all'interno della vendita) ricevo il seguente errore:

Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 54 bytes)

128M è il valore predefinito in php.ini, ma presumo che sia un numero enorme da interrompere. In effetti, ho anche provato a impostare questo valore su 1024M, e tutto ciò che serve è impiegare più tempo a errori.

Per quanto riguarda i passaggi che ho fatto, ho provato a disabilitare tutta l'elaborazione sul lato server e l'ho truccato per restituire una risposta predefinita indipendentemente dall'input. Tuttavia, credo che il problema risieda nell'effettivo invio dei dati. Ho anche provato a disabilitare il tempo massimo di esecuzione dello script per PHP, e continua a fuoriuscire.

Cambiare il memory_limitby nonini_set('memory_limit', '-1'); è una soluzione adeguata. Per favore, non farlo.

Il tuo codice PHP potrebbe avere una perdita di memoria da qualche parte e stai dicendo al server di usare solo tutta la memoria che desidera. Non avresti risolto il problema. Se monitori il tuo server, noterai che ora sta probabilmente utilizzando la maggior parte della RAM e addirittura scambiando su disco.

Probabilmente dovresti provare a rintracciare il codice offensivo nel tuo codice e risolverlo.

ini_set('memory_limit', '-1');ignora il limite di memoria PHP predefinito .

Il modo corretto è modificare il tuo php.inifile. Modifica memory_limitsecondo il tuo valore desiderato.

A partire dalla tua domanda, 128M(che è il limite predefinito) è stato superato, quindi c'è qualcosa di gravemente sbagliato nel tuo codice in quanto non dovrebbe richiedere molto.

Se sai perché ci vuole così tanto e vuoi permetterlo impostato memory_limit = 512Mo superiore e dovresti essere buono.

L'allocazione di memoria per PHP può essere regolata permanentemente o temporaneamente.

Permanentemente

È possibile modificare in modo permanente l'allocazione della memoria PHP in due modi.

Se hai accesso al tuo php.inifile, puoi modificare il valore per memory_limitil valore desiderato.

Se non hai accesso al tuo php.inifile (e il tuo webhost lo consente), puoi sovrascrivere l'allocazione di memoria attraverso il tuo .htaccessfile. Aggiungi php_value memory_limit 128M(o qualunque sia l'allocazione desiderata).

Temporaneo

È possibile regolare l'allocazione di memoria al volo da un file PHP. Hai semplicemente il codice ini_set('memory_limit', '128M');(o qualunque sia l'allocazione desiderata). È possibile rimuovere il limite di memoria (sebbene i limiti della macchina o dell'istanza possano ancora essere applicati) impostando il valore su "-1".

È molto facile ottenere perdite di memoria in uno script PHP, specialmente se si utilizza l'astrazione, come un ORM. Prova a usare Xdebug per profilare il tuo script e scoprire dove è finita tutta quella memoria.

Quando ho aggiunto 22,5 milioni di record in un array con array_push ho continuato a ricevere errori fatali "memoria esaurita" a circa 20 milioni di record usando 4Gcome limite di memoria nel file php.ini. Per risolvere questo problema, ho aggiunto la dichiarazione

$old = ini_set('memory_limit', '8192M');

nella parte superiore del file. Ora tutto funziona bene. Non so se PHP ha una perdita di memoria. Questo non è il mio lavoro, né me ne importa. Devo solo fare il mio lavoro e questo ha funzionato.

Il programma è molto semplice:

$fh = fopen($myfile);
while (!feof($fh)) {
    array_push($file, stripslashes(fgets($fh)));
}
fclose($fh);

L'errore irreversibile punta alla riga 3 fino a quando non ho aumentato il limite di memoria, che ha eliminato l'errore.

Ho continuato a ricevere questo errore, anche con memory_limitset in php.ini, e il valore letto correttamente phpinfo().

Modificandolo da questo:

memory_limit=4G

A questo:

memory_limit=4096M

Questo ha risolto il problema in PHP 7.

Quando vedi l'errore sopra - specialmente se (tried to allocate __ bytes)è un valore basso, potrebbe essere un indicatore di un ciclo infinito, come una funzione che si chiama senza via d'uscita:

function exhaustYourBytes()
{
    return exhaustYourBytes();
}

Dopo aver abilitato queste due linee, ha iniziato a funzionare:

; Determines the size of the realpath cache to be used by PHP. This value should
; be increased on systems where PHP opens many files to reflect the quantity of
; the file operations performed.
; http://php.net/realpath-cache-size
realpath_cache_size = 16k

; Duration of time, in seconds for which to cache realpath information for a given
; file or directory. For systems with rarely changing files, consider increasing this
; value.
; http://php.net/realpath-cache-ttl
realpath_cache_ttl = 120

Puoi risolverlo correttamente cambiando memory_limitsu fastcgi / fpm:

$vim /etc/php5/fpm/php.ini

Cambia memoria, come da 128 a 512, vedi sotto

; Maximum amount of memory a script may consume (128 MB)
; http://php.net/memory-limit
memory_limit = 128M

per

; Maximum amount of memory a script may consume (128 MB)
; http://php.net/memory-limit
memory_limit = 512M

Directory principale del tuo sito:

ini_set('memory_limit', '1024M');

Modifica il limite di memoria nel file php.ini e riavvia Apache. Dopo il riavvio, eseguire phpinfo (); funzione da qualsiasi file PHP per una memory_limitconferma di modifica.

memory_limit = -1

Il limite di memoria -1 indica che non è stato impostato alcun limite di memoria. Adesso è al massimo.

Per gli utenti di Drupal, la risposta di Chris Lane a:

ini_set('memory_limit', '-1');

funziona ma dobbiamo metterlo subito dopo l'apertura

<?php

tag nel file index.php nella directory principale del tuo sito.

In Drupal 7, puoi modificare il limite di memoria nel file settings.php situato nella cartella siti / predefinita. Intorno alla linea 260, vedrai questo:

ini_set('memory_limit', '128M');

Anche se le tue impostazioni php.ini sono abbastanza alte, non sarai in grado di consumare più di 128 MB se questo non è impostato nel tuo file settings.php Drupal.

Invece di modificare il memory_limitvalore nel tuo php.inifile, se c'è una parte del tuo codice che potrebbe usare molta memoria, puoi rimuovere memory_limitprima dell'esecuzione di quella sezione e poi sostituirla dopo.

$limit = ini_get('memory_limit');
ini_set('memory_limit', -1);
// ... do heavy stuff
ini_set('memory_limit', $limit);

PHP 5.3+ consente di modificare il limite di memoria inserendo un .user.inifile nella public_htmlcartella. Basta creare il file sopra e digitare la seguente riga in esso:

memory_limit = 64M

Alcuni host cPanel accettano solo questo metodo.

Pagina di arresto?

(Succede quando MySQL deve interrogare file di grandi dimensioni. Per impostazione predefinita, memory_limit è impostato su piccolo, il che era più sicuro per l'hardware.)

È possibile controllare lo stato della memoria esistente del sistema, prima di aumentare php.ini:

# free -m
             total       used       free     shared    buffers     cached
Mem:         64457      63791        666          0       1118      18273
-/+ buffers/cache:      44398      20058
Swap:         1021          0       1021

Qui l'ho aumentato come nel seguito e quindi faccio service httpd restartper risolvere il problema della pagina di arresto anomalo.

# grep memory_limit /etc/php.ini
memory_limit = 512M

Aggiungi una ini_set('memory_limit', '-1');riga nella parte superiore della tua pagina web.

E puoi impostare la tua memoria secondo le tue necessità al posto di -1, a 16M, ecc.

Per coloro che si grattano la testa per scoprire perché mai questa piccola funzione dovrebbe causare una perdita di memoria, a volte per un piccolo errore, una funzione inizia ricorsivamente chiamandosi per sempre.

Ad esempio, una classe proxy che ha lo stesso nome per una funzione dell'oggetto che sta per proxy.

class Proxy {

    private $actualObject;

    public function doSomething() {

        return $this->actualObjec->doSomething();
    }
}

A volte potresti dimenticare di portare quel piccolo membro effettivo di Objec e poiché il proxy ha effettivamente quel doSomethingmetodo, PHP non ti darebbe alcun errore e per una grande classe, potrebbe essere nascosto agli occhi per un paio di minuti per scoprire perché perde la memoria.

Ho avuto l'errore di seguito durante l'esecuzione su un set di dati più piccolo di quanto avesse funzionato in precedenza.

Errore irreversibile: dimensione della memoria consentita di 134217728 byte esauriti (tentato di allocare 4096 byte) in C: \ workspace \ image_management.php sulla riga 173

Dato che la ricerca dell'errore mi ha portato qui, ho pensato di menzionare che non sono sempre le soluzioni tecniche nelle risposte precedenti, ma qualcosa di più semplice. Nel mio caso era Firefox. Prima di eseguire il programma utilizzava già 1.157 MB.

Si è scoperto che avevo guardato un video di 50 minuti un po 'alla volta per un periodo di giorni e questo ha rovinato le cose. È il tipo di correzione che gli esperti correggono senza nemmeno pensarci, ma per quelli come me vale la pena ricordare.

Eseguendo lo script in questo modo (caso cron per esempio): php5 /pathToScript/info.phpproduce lo stesso errore.

Il modo corretto: php5 -cli /pathToScript/info.php

Se si esegue un VPS (server privato virtuale) basato su WHM, è possibile che non si disponga delle autorizzazioni per modificare direttamente PHP.INI; il sistema deve farlo. Nel pannello di controllo dell'host WHM, vai a Configurazione servizio → Editor di configurazione PHP e modifica memory_limit:

Lo trovo utile quando includo o richiedo _dbconnection.php_e _functions.phpnei file che vengono effettivamente elaborati, piuttosto che includere nell'intestazione. Che è incluso in sé.

Quindi, se l' intestazione e il piè di pagina sono inclusi, è sufficiente includere tutti i file funzionali prima di includere l'intestazione.

L'uso yieldpotrebbe anche essere una soluzione. Vedi Sintassi del generatore .

Invece di modificare il PHP.inifile per una memoria più grande, a volte l'implementazione di yieldun ciclo interno potrebbe risolvere il problema. Ciò che fa la resa è invece di scaricare tutti i dati in una volta, li legge uno per uno, risparmiando un sacco di utilizzo della memoria.

Questo errore è talvolta causato da un bug nel codice PHP che provoca ricorsioni che coinvolgono la gestione delle eccezioni e possibilmente altre operazioni. Sfortunatamente, non sono stato in grado di creare un piccolo esempio.

In questi casi, che sono accaduti più volte per me, set_time_limit , il browser continua a provare a caricare l'output di PHP, con un ciclo infinito o con il messaggio di errore fatale che è l'argomento di questa domanda.

Riducendo la dimensione di allocazione consentita aggiungendo

ini_set('memory_limit','1M');

vicino all'inizio del codice dovresti essere in grado di prevenire l'errore fatale.

Quindi potresti rimanere con un programma che termina, ma è comunque difficile eseguire il debug.

A questo punto inserisci le BreakLoop()chiamate all'interno del tuo programma per ottenere il controllo e scoprire quale loop o ricorsione nel tuo programma sta causando il problema.

La definizione di BreakLoop è la seguente:

function BreakLoop($MaxRepetitions=500,$LoopSite="unspecified")
    {
    static $Sites=[];
    if (!@$Sites[$LoopSite] || !$MaxRepetitions)
        $Sites[$LoopSite]=['n'=>0, 'if'=>0];
    if (!$MaxRepetitions)
        return;
    if (++$Sites[$LoopSite]['n'] >= $MaxRepetitions)
        {
        $S=debug_backtrace(); // array_reverse
        $info=$S[0];
        $File=$info['file'];
        $Line=$info['line'];
        exit("*** Loop for site $LoopSite was interrupted after $MaxRepetitions repetitions. In file $File at line $Line.");
        }
    } // BreakLoop

L'argomento $ LoopSite può essere il nome di una funzione nel tuo codice. Non è davvero necessario, poiché il messaggio di errore che riceverai ti indicherà la linea contenente la chiamata BreakLoop ().

Nel mio caso è stato un breve problema con il modo in cui è stata scritta una funzione. Una perdita di memoria può essere causata assegnando un nuovo valore alla variabile di input di una funzione, ad esempio:

/**
* Memory leak function that illustrates unintentional bad code
* @param $variable - input function that will be assigned a new value
* @return null
**/
function doSomehting($variable){
    $variable = 'set value';
    // Or
    $variable .= 'set value';
}

Quando ho rimosso le seguenti righe dal mio codice, tutto ha funzionato bene!

set_include_path(get_include_path() . get_include_path() . '/phpseclib');
include_once('Net/SSH2.php');
include_once('Net/SFTP.php');

Queste righe sono state incluse in ogni file che stavo eseguendo. Quando eseguivo i file uno per uno, tutto funzionava bene, ma quando eseguivo tutti i file insieme ho avuto il problema di perdita di memoria. In qualche modo il "include_once" non include le cose una volta, o sto facendo qualcosa di sbagliato ...