Como 'copiar' a matriz sem criar uma matriz temporária na memória que causou estouro de memória?

Ao atribuir uma matriz a uma memória alocada muito maior, o matlab de alguma forma a duplicará enquanto a 'copia' e, se a matriz a ser copiada for grande o suficiente, haverá excesso de memória. Este é o código de exemplo:

main_mat=zeros(500,500,2000);
n=500;
slice_matrix=zeros(500,500,n);
for k=1:4
    parfor i=1:n
        slice_matrix(:,:,i)=gather(gpuArray(rand(500,500)));
    end
    main_mat(:,:,1+(k-1)*n:1+(k-1)*n+n-1)=slice_matrix; %This is where the memory will likely overflow
end

Alguma maneira de simplesmente 'esmagar' o slice_matrixpara o main_matsem a sobrecarga? Desde já, obrigado.

EDITAR:

O estouro ocorreu quando main_maté alocado previamente. Se main_matfor inicializado com main_mat=zeros(500,500,1);(tamanho menor), o estouro não ocorrerá, mas diminuirá a velocidade, pois a alocação não é feita antes que a matriz seja atribuída a ela. Isso reduzirá significativamente o desempenho conforme o intervalo de kaumentos.

A questão principal é que os números ocupam mais espaço que zeros. consome main_mat=zeros(500,500,2000);pouca RAM e main_mat = rand(500,500,2000);consome muito, não importa se você usa GPU ou parfor (na verdade, o parfor fará com que você use mais RAM). Portanto, este não é um inchaço artificial da memória. Seguindo o link de Daniel abaixo, parece que a atribuição de zeros cria apenas ponteiros para a memória, e a memória física é preenchida apenas quando você usa a matriz para "números". Isso é gerenciado pelo sistema operacional. E isso é esperado para Windows, Mac e Linux, seja com Matlab ou com outros idiomas como C.

A remoção parforprovavelmente corrigirá seu problema.

parfornão é útil lá. O MATLAB parfornão usa paralelismo de memória compartilhada (ou seja, não inicia novos threads), mas sim paralelismo de memória distribuída (inicia novos processos). Ele foi projetado para distribuir trabalho por um conjunto ou nós de trabalho. E, embora também funcione em um nó (ou em um único computador desktop) para distribuir o trabalho em vários núcleos, não é uma maneira ideal de fazer paralelismo em um nó.

Isso significa que cada um dos processos iniciados por parforprecisa ter sua própria cópia slice_matrix, o que é a causa da grande quantidade de memória usada pelo seu programa.

Consulte "Decidir quando usar parfor" na documentação do MATLAB para saber mais sobre parfore quando usá-lo.

Presumo que seu código seja apenas um exemplo de código e que rand()represente um costume no seu MVE. Portanto, existem algumas dicas e truques para o uso da memória no matlab.

Há um trecho dos manuais de treinamento do MathWorks:

Ao atribuir uma variável a outra no MATLAB, como ocorre ao passar parâmetros para uma função, o MATLAB cria de forma transparente uma referência a essa variável. O MATLAB quebra a referência e cria uma cópia dessa variável, apenas quando o código modifica um ou mais dos valores. Esse comportamento, conhecido como cópia na gravação ou cópia lenta , adia o custo de copiar grandes conjuntos de dados até que o código modifique um valor. Portanto, se o código não executar modificações, não será necessário espaço extra na memória e tempo de execução para copiar variáveis.

A primeira coisa a fazer seria verificar a eficiência (memória) do seu código. Até o código de excelentes programadores pode ser otimizado ainda mais com (um pouco) poder do cérebro. Aqui estão algumas dicas sobre eficiência de memória

• Faça uso da vetorização nativ de Matlab, por exemplo sum(X,2), mean(X,2),std(X,[],2)
• verifique se o matlab não precisa expandir matrizes (a expansão implícita foi alterada recentemente). Pode ser mais eficiente usar obsxfun
• use operações no local, por exemplo, em x = 2*x+3vez dex = 2*x+3
• ...

Esteja ciente de que o melhor em relação ao uso da memória não é o mesmo como se você desejasse reduzir o tempo de computação. Portanto, convém reduzir o número de trabalhadores ou deixar de usar o parforloop. (Como parfornão é possível usar a memória compartilhada, não há recurso de copiar na gravação usando o Parallel Toolbox.

Se você deseja examinar mais de perto sua memória , o que está disponível e pode ser usado pelo Matlab, confira feature('memstats'). O que é interessante para você é a memória virtual que é

Memória total e disponível associada a todo o processo MATLAB. É limitado pela arquitetura do processador e sistema operacional. ou use este comando [user,sys] = memory.

Nó lateral rápido : o Matlab armazena matrizes de forma consistente na memória. Você precisa ter um grande bloco de RAM livre para matrizes grandes. Essa também é a razão pela qual você deseja alocar variáveis, porque alterá-las dinamicamente força o Matlab a copiar toda a matriz para um ponto maior na RAM toda vez que ele ultrapassa o ponto atual.

Se você realmente tem problemas de memória , pode apenas querer explorar a arte dos tipos de dados - como é necessário nos idiomas de nível inferior. Por exemplo, você pode reduzir o uso de memória pela metade usando precisão única diretamente desde o início main_mat=zeros(500,500,2000,'single');- aliás, isso também funciona com rand(...,'single')e mais funções nativas - embora algumas das funções mais sofisticadas do matlab exijam entrada do tipo double, que você pode upcast novamente.

Se bem entendi, o seu problema principal é que parfornão permite compartilhar memória. Pense em cada parfor worker como quase uma instância separada do matlab.

Basicamente, existe apenas uma solução alternativa para isso que eu conheço (que nunca tentei), que é 'matriz compartilhada' no Fileexchange: https://ch.mathworks.com/matlabcentral/fileexchange/28572-sharedmatrix

Mais soluções: como outros sugeriram: remover o parfor é certamente uma solução, obtenha mais memória RAM, use matrizes altas (que usam discos rígidos quando a memória RAM está cheia, leia aqui ), divida operações em partes menores, por último, mas não menos importante, considere uma alternativa diferente de Matlab.

Você pode usar o seguinte código. Você realmente não precisa do slice_matrix

main_mat=zeros(500,500,2000);
n=500;
slice_matrix=zeros(500,500,n);
for k=1:4
   parfor i=1:n
       main_mat(:,:,1+(k-1)*n + i - 1) = gather(gpuArray(rand(500,500)));
   end
   %% now you don't need this main_mat(:,:,1+(k-1)*n:1+(k-1)*n+n-1)=slice_matrix; %This is where the memory will likely overflow
end