Erro fatal: tamanho de memória permitido de 134217728 bytes esgotados (CodeIgniter + XML-RPC)

Eu tenho vários sistemas de ponto de venda (POS) do cliente que enviam periodicamente novos dados de vendas para um banco de dados centralizado, que armazena os dados em um grande banco de dados para geração de relatórios.

O POS do cliente é baseado no PHPPOS, e eu implementei um módulo que usa a biblioteca XML-RPC padrão para enviar dados de vendas ao serviço. O sistema do servidor é construído no CodeIgniter e usa as bibliotecas XML-RPC e XML-RPCS para o componente de serviço da web. Sempre que envio muitos dados de vendas (apenas 50 linhas da tabela de vendas e linhas individuais de sales_items pertencentes a cada item da venda), recebo o seguinte erro:

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

128M é o valor padrão php.ini, mas presumo que seja um número enorme para quebrar. Na verdade, eu até tentei definir esse valor para 1024M, e tudo o que faz é levar mais tempo para ocorrer um erro.

Quanto às etapas que eu tomei, tentei desabilitar todo o processamento no lado do servidor e o montei para retornar uma resposta fixa, independentemente da entrada. No entanto, acredito que o problema está no envio real dos dados. Eu até tentei desabilitar o tempo máximo de execução de script para PHP, e ele ainda gera erros.

Alterar o memory_limitby nãoini_set('memory_limit', '-1'); é uma solução adequada. Por favor, não faça isso.

Seu código PHP pode ter um vazamento de memória em algum lugar e você está dizendo ao servidor para usar apenas toda a memória que ele deseja. Você não teria resolvido o problema. Se você monitorar seu servidor, verá que agora está provavelmente usando a maior parte da RAM e até trocando para o disco.

Você provavelmente deve tentar rastrear o código incorreto no seu código e corrigi-lo.

ini_set('memory_limit', '-1');substitui o limite de memória PHP padrão .

A maneira correta é editar seu php.iniarquivo. Edite memory_limitpara o seu valor desejado.

A partir da sua pergunta 128M(que é o limite padrão) foi excedida, há algo seriamente errado no seu código, pois não deve demorar muito.

Se você sabe por que é preciso muito e deseja permitir que o valor seja definido memory_limit = 512Mou superior, você deve ser bom.

A alocação de memória para PHP pode ser ajustada permanentemente ou temporariamente.

Permanentemente

Você pode alterar permanentemente a alocação de memória PHP de duas maneiras.

Se você tiver acesso ao seu php.iniarquivo, poderá editar o valor para memory_limito valor desejado.

Se você não tiver acesso ao seu php.iniarquivo (e o seu host permitir), poderá substituir a alocação de memória pelo seu .htaccessarquivo. Adicione php_value memory_limit 128M(ou seja qual for a alocação desejada).

Temporário

Você pode ajustar a alocação de memória em tempo real a partir de um arquivo PHP. Você simplesmente tem o código ini_set('memory_limit', '128M');(ou qualquer que seja a alocação desejada). Você pode remover o limite de memória (embora os limites da máquina ou da instância ainda possam se aplicar), definindo o valor como "-1".

É muito fácil obter vazamentos de memória em um script PHP - especialmente se você usar abstração, como um ORM. Tente usar o Xdebug para criar um perfil do seu script e descobrir para onde foi toda essa memória.

Ao adicionar 22,5 milhões de registros em uma matriz com array_push, eu continuava recebendo erros fatais de "memória esgotada" em cerca de 20 milhões de registros usando 4Gcomo limite de memória no arquivo php.ini. Para corrigir isso, adicionei a declaração

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

na parte superior do arquivo. Agora tudo está funcionando bem. Eu não sei se o PHP tem um vazamento de memória. Esse não é o meu trabalho, nem me importo. Eu só tenho que fazer meu trabalho, e isso funcionou.

O programa é muito simples:

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

O erro fatal aponta para a linha 3 até eu aumentar o limite de memória, o que eliminou o erro.

Eu continuava recebendo esse erro, mesmo com memory_limitset in php.ini, e o valor sendo lido corretamente com phpinfo().

Alterando-o a partir disso:

memory_limit=4G

Para isso:

memory_limit=4096M

Isso corrigiu o problema no PHP 7.

Quando você vê o erro acima - especialmente se o (tried to allocate __ bytes)valor é baixo, isso pode ser um indicador de um loop infinito, como uma função que se chama sem saída:

function exhaustYourBytes()
{
    return exhaustYourBytes();
}

Depois de ativar essas duas linhas, ele começou a funcionar:

; 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

Você pode corrigir isso corretamente, alterando o memory_limitfastcgi / fpm:

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

Mude a memória, como de 128 para 512, veja abaixo

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

para

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

Diretório raiz do seu site:

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

Altere o limite de memória no arquivo php.ini e reinicie o Apache. Após o reinício, execute o phpinfo (); função de qualquer arquivo PHP para uma memory_limitconfirmação de alteração.

memory_limit = -1

Limite de memória -1 significa que não há limite de memória definido. Agora está no máximo.

Para usuários do Drupal, esta resposta de Chris Lane:

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

funciona, mas precisamos colocá-lo logo após a abertura

<?php

no arquivo index.php no diretório raiz do seu site.

No Drupal 7, você pode modificar o limite de memória no arquivo settings.php localizado na sua pasta sites / padrão. Na linha 260, você verá o seguinte:

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

Mesmo que suas configurações de php.ini sejam altas o suficiente, você não poderá consumir mais de 128 MB se isso não estiver definido no seu arquivo Drupal settings.php.

Em vez de alterar o memory_limitvalor do seu php.iniarquivo, se houver uma parte do seu código que possa usar muita memória, você poderá remover o memory_limitantes dessa seção e substituí-lo depois.

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

O PHP 5.3+ permite alterar o limite de memória colocando um .user.iniarquivo na public_htmlpasta Simplesmente crie o arquivo acima e digite a seguinte linha:

memory_limit = 64M

Alguns hosts cPanel aceitam apenas esse método.

Bater página?

(Isso acontece quando o MySQL precisa consultar linhas grandes. Por padrão, memory_limit é definido como pequeno, o que era mais seguro para o hardware.)

Você pode verificar o status da memória existente do sistema antes de aumentar 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

Aqui eu a ampliei como a seguir e depois o faço service httpd restartpara corrigir o problema da página de falha.

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

Basta adicionar uma ini_set('memory_limit', '-1');linha na parte superior da sua página da web.

E você pode definir sua memória conforme sua necessidade no lugar de -1, para 16M, etc.

Para aqueles que estão coçando a cabeça para descobrir por que diabos essa pequena função deve causar um vazamento de memória, às vezes por um pequeno erro, uma função começa a se chamar recursivamente para sempre.

Por exemplo, uma classe de proxy que tem o mesmo nome para uma função do objeto que o fará proxy.

class Proxy {

    private $actualObject;

    public function doSomething() {

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

Às vezes, você pode esquecer de trazer esse pequeno membro realObjec e, como o proxy realmente possui esse doSomethingmétodo, o PHP não forneceria nenhum erro e, para uma classe grande, ele poderia ficar oculto por alguns minutos para descobrir por que está vazando a memória.

Ocorreu o erro abaixo ao executar em um conjunto de dados menor do que o que funcionava anteriormente.

Erro fatal: tamanho de memória permitido de 134217728 bytes esgotado (tentou alocar 4096 bytes) em C: \ workspace \ image_management.php na linha 173

Como a busca pela falha me trouxe aqui, pensei em mencionar que nem sempre são as soluções técnicas nas respostas anteriores, mas algo mais simples. No meu caso, foi o Firefox. Antes de executar o programa, ele já estava usando 1.157 MB.

Acontece que eu estava assistindo um vídeo de 50 minutos, um pouco de cada vez, durante um período de dias, e isso estragou tudo. É o tipo de correção que os especialistas corrigem sem nem pensar, mas para mim vale a pena lembrar.

A execução do script como este (caso cron, por exemplo): php5 /pathToScript/info.phpproduz o mesmo erro.

A maneira correta: php5 -cli /pathToScript/info.php

Se você estiver executando um VPS (servidor privado virtual) com WHM, poderá descobrir que não possui permissões para editar o PHP.INI diretamente; o sistema deve fazer isso. No painel de controle do host do WHM, vá para Service Configuration → PHP Configuration Editor e modifique memory_limit:

Acho útil quando incluir ou exigir _dbconnection.php_e _functions.phpnos arquivos realmente processados, em vez de incluir no cabeçalho. O que está incluído em si.

Portanto, se o cabeçalho e o rodapé estiverem incluídos, basta incluir todos os seus arquivos funcionais antes da inclusão do cabeçalho.

Usar yieldpode ser uma solução também. Consulte Sintaxe do gerador .

Em vez de alterar o PHP.iniarquivo para um armazenamento de memória maior, às vezes a implementação de yieldum loop interno pode corrigir o problema. O que o rendimento faz é, em vez de descarregar todos os dados de uma vez, ele os lê um por um, economizando muito uso de memória.

Às vezes, esse erro é causado por um bug no código PHP que causa recursões envolvendo manipulação de exceções e possivelmente outras operações. Infelizmente, não consegui criar um pequeno exemplo.

Nestes casos, o que aconteceu várias vezes, set_time_limitfalha e o navegador continua tentando carregar a saída do PHP, com um loop infinito ou com a mensagem de erro fatal que é o tópico desta pergunta.

Reduzindo o tamanho de alocação permitido adicionando

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

próximo ao início do seu código, você poderá evitar o erro fatal.

Em seguida, você pode ficar com um programa que termina, mas ainda é difícil de depurar.

Nesse ponto, insira BreakLoop()chamadas dentro do seu programa para obter controle e descobrir qual loop ou recursão no seu programa está causando o problema.

A definição de BreakLoop é a seguinte:

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

O argumento $ LoopSite pode ser o nome de uma função no seu código. Não é realmente necessário, pois a mensagem de erro que você receberá apontará para a linha que contém a chamada BreakLoop ().

No meu caso, foi um breve problema com a forma como uma função foi escrita. Um vazamento de memória pode ser causado pela atribuição de um novo valor à variável de entrada de uma função, por exemplo:

/**
* 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 removi as seguintes linhas do meu código, tudo funcionou bem!

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

Essas linhas foram incluídas em todos os arquivos que eu estava executando. Ao executar os arquivos um por um, tudo funcionou bem, mas ao executar todos os arquivos juntos, tive o problema de vazamento de memória. De alguma forma, o "include_once" não está incluindo as coisas uma vez, ou estou fazendo algo errado ...