Eu estou tentando executar o seguinte programa, que calcula raízes de polinômios de grau até d com coeficientes apenas +1 ou -1 e, em seguida, armazená-lo em arquivos.

d = 20; n = 18000; 
f[z_, i_] := Sum[(2 Mod[Floor[(i - 1)/2^k], 2] - 1) z^(d - k), {k, 0, d}];

Aqui f [z, i] fornece um polinômio em z com sinais de mais ou menos contando em binário. Diga d = 2, teríamos

f [z, 1] = -z2 - z - 1
f [z, 2] = -z2 - z + 1
f [z, 3] = -z2 + z - 1
f [z, 4] = -z2 + z + 1

DistributeDefinitions[d, n, f]

ParallelDo[ 
            Do[ 
                     root = N[Root[f[z, i], j]];
                     {a, b} = Round[n ({Re[root], Im[root]}/1.5 + 1)/2];
            {i, 1, 2^d}],
{j, 1, d}]

Eu percebo que ler isso provavelmente não é muito agradável, mas é relativamente curto de qualquer maneira. Eu teria tentado reduzir as partes relevantes, mas aqui eu realmente não tenho idéia de qual é o problema. Estou calculando todas as raízes de f [z, i] e, em seguida, apenas arredondá-las para fazê-las corresponder a um ponto em uma grade n por n e salvar esses dados em vários arquivos.

Por alguma razão, o uso de memória no Mathematica se acumula até preencher toda a memória (6 GB nesta máquina); então a computação continua extremamente devagar; por que é isso?

Não tenho certeza do que está consumindo a memória aqui - meu único palpite foi o fluxo de arquivos usados ​​na memória, mas não é o caso: tentei anexar dados a arquivos de 2 GB e não houve uso de memória perceptível para isso. Parece não haver absolutamente nenhuma razão para o Mathematica estar usando grandes quantidades de memória aqui.

Para valores pequenos de d (15 por exemplo), o comportamento é o seguinte: Eu tenho 4 kernels em execução. Como todos eles percorrem o loop ParallelDo (cada um fazendo um valor de j de cada vez), o uso da memória aumenta, até que todos terminem de passar pelo loop uma vez. Então, nas próximas vezes que passam por esse loop, o uso de memória não aumenta de forma alguma. O cálculo acaba e tudo está bem.

Além disso, muito importante, quando o cálculo é interrompido, o uso da memória não volta para baixo. Se eu começar outro cálculo, acontece o seguinte:

-Se o cálculo anterior parou quando o uso de memória ainda estava aumentando, ele continua a aumentar (pode demorar um pouco para começar a aumentar novamente, basicamente para chegar ao mesmo ponto no cálculo).

-Se o cálculo anterior parou quando o uso de memória não estava aumentando, ele não aumenta mais.

Editar: A questão parece vir da complexidade relativa de f - mudá-lo em algum polinômio mais fácil parece corrigir o problema. Eu pensei que o problema poderia ser que o Mathematica lembra f [z, i] para valores específicos de i, mas definindo f [z, i]: =. logo após calcular uma raiz de f [z, i] reclama que a atribuição não existia em primeiro lugar, e a memória ainda é usada.

É realmente confuso, já que f é a única coisa remanescente que posso imaginar ocupando memória, mas definir f no loop Do e fazer o clearing cada vez que uma raiz é calculada não resolve o problema.