Andrew H's questions

Um colega e eu estávamos revisando algumas propostas de alunos. Ele gosta de usar o IDLE, enquanto eu uso o PyCharm. O aluno desenvolveu seu código no PyCharm. Um exemplo simplificado do trabalho do aluno é:

file = open('test_file.txt','w')
file.write('This is a test file.')
print('Completed')
exit()

O aluno cometeu um erro no tratamento do arquivo e criou uma situação em que o arquivo ficou aberto após a conclusão do código.

Quando executado no PyCharm, o comando file.write é concluído e o arquivo é atualizado conforme o esperado. Quando executado no IDLE, o comando file.write parece não ter sido concluído e o arquivo está vazio. Quando executado na linha de comando (aliás, todos nós usamos Macbooks), o comando file.write é concluído e o arquivo contém a linha de texto. Outra dica é que, ao ser executado no IDLE, após a mensagem "Concluído" ser exibida, aparece uma caixa de diálogo do sistema que diz: "Seu programa ainda está em execução! Deseja encerrá-lo?". Este aviso não aparece quando executado na linha de comando ou no PyCharm.

Estamos tentando entender a diferença entre esses comportamentos, pois acreditamos que todos eles realizam o mesmo processo de invocar o mesmo intérprete.

Estou brincando com ARM Assembly em uma instalação de 64 bits do Raspbian em um Pi3-B +. O código determina se um valor é primo ou não.

1   
2   .data
3   testvalue: 
4       .word 0             // The number we are going to test
5   factor: 
6       .word 0         // The number we are going to test as a factor
7   limit: 
8       .word 0         // The top of the loop. testvalue - 1
9   isPrimeMsg: 
10      .asciz "%d is a prime number.\n"
11  isNotPrimeMsg: 
12      .asciz "%d is not a prime number.\n"
13  scanpattern: 
14      .asciz "%d"
15  prompt: 
16      .asciz "Input a test value: "
17  tooSmallMsg: 
18      .asciz "%d is too small.  Value must be > 5.\n"
19  diagnostic:
20      .asciz "%d, %d, %d.\n"
21
    22  .text
23  .global main
24  
25  main:
26      LDR X0, =prompt     // Load X0 with the input prompt
27      BL printf           // Print the input prompt 
28  
29      LDR X0, =scanpattern    // Load X0 with the scan pattern
30      LDR X1, =testvalue      // Load X1 with the address to store the user input
31      BL scanf            // get the user input and store it at testvalue address
32  
33      LDR X0, =testvalue      // Load X0 with the address of testvalue
34      LDR X0, [X0]            // Load X0 with the actual test value, currently 0
35      MOV X1, #5          // Load 5 into X1
36      CMP X0, X1          // Perform X0 - X1
37      BMI toosmall            // If the result is negative then test value < 5.  Jump to inform user
38  
39      LDR X0, =testvalue      // Load X1 with the address of the test value
40      LDR X0, [X0]            // Load X1 with actual test value
41      SUB X0, X0, #1      // Subtract 1 from testvalue
42      LDR X1, =limit
43      STR X0, [X1]            // Store the result in address of upper limit
44  
45      LDR X0, =factor     // Load X0 with the address of factor
46      MOV X1, #2          // Load X1 with the immediate value 2
47      STR X1, [X0]            // Store 2 at the address of factor
48  
49      LDR X0, =diagnostic     // Load X0 with diagnostic string
50      LDR X1, =testvalue      // Load X1 with address of testvalue
51      LDR X1, [X1]            // Load X1 with value of testvalue
52      LDR X2, =limit      // Load X2 with address of limit
53      LDR X2, [X2]            // Load X2 with value of limit
54      LDR X3, =factor     // Load X3 with address of factor
55      LDR X3, [X3]            // Load X3 with value of factor
56      BL printf           // Print diagnostic string
57  
58  
59  checkfactor:
60      LDR X0, =testvalue      // Load X0 with address of testvalue
61      LDR X0, [X0]            // Load X0 with the test value
62      LDR X1, =factor     // Load X1 with address of factor
63      LDR X1, [X1]            // Load X1 with the current factor candidate
64      LDR X2, =limit      // Load X2 with address of limit
65      LDR X2, [X2]            // Load X2 with the value for upper limit
66      CMP X2, X1          // Check if the factor value has reached the upper limit
67      BEQ isPrime         // If it has and we have not failed yet then we have a prime number
68  
69  subtractloop:
70      CMP X0, #0          // Compare the current testvalue with zero
71      BEQ notPrime        // If it is then we have a factor and the test value is not prime
72      BMI nextfactor      // If it's gone negative then it's time to test the next factor
73      SUB X0, X0, X1      // Otherwise keep doing division by subraction
74  
75  nextfactor:
76      LDR X0, =factor     // Load X0 with addresss of factor
77      LDR X1, [X0]            // Load X0 with value of factor
78      ADD X1, X1, #1      // Increment the value of factor by 1
79      STR X1, [X0]            // Store new value of factor in address of factor
80      B checkfactor           // Jump back and start testing again
81  
82  toosmall:
83      LDR X0, =tooSmallMsg
84      LDR X1, = testvalue
85      LDR X1, [X1]
86      BL printf
87      B end
88  
89  notPrime:
90      LDR X0, =isNotPrimeMsg
91      LDR X1, =testvalue
92      LDR X1, [X1]
93      BL printf
94      B end
95  
96  isPrime:
97      LDR X0, =isPrimeMsg
98      LDR X1, =testvalue
99      LDR X1, [X1]
100     BL printf
101     B end
102 
103 end:
104     B exit

O problema ocorre entre as linhas 39 e 49. Especificamente quando a linha 47 é executada. A saída do GDB é semelhante a:

39      LDR X0, =testvalue      // Load X1 with the address of the test value
(gdb) stepi
40      LDR X0, [X0]            // Load X1 with actual test value
(gdb) stepi
41      SUB X0, X0, #1          // Subtract 1 from testvalue
(gdb) i r x0
x0             0x13                19
(gdb) p (int)testvalue
$2 = 19
(gdb) stepi
42      LDR X1, =limit
(gdb) stepi
43      STR X0, [X1]            // Store the result in address of upper limit
(gdb) i r x0
x0             0x12                18
(gdb) p (int)limit
$3 = 0
(gdb) stepi
45      LDR X0, =factor         // Load X0 with the address of factor
(gdb) p (int)limit
$4 = 18
(gdb) stepi
46      MOV X1, #2          // Load X1 with the immediate value 2
(gdb) p (int)limit
$5 = 18
(gdb) stepi
47      STR X1, [X0]            // Store 2 at the address of factor
(gdb) i r x1
x1             0x2                 2
(gdb) p (int)limit
$6 = 18
(gdb) stepi
49      LDR X0, =diagnostic     // Load X0 with diagnostic string
(gdb) p (int)limit
$7 = 0
(gdb) p (int)testvalue
$8 = 19
(gdb) p (int)limit
$9 = 0
(gdb) p (int)factor
$10 = 2
(gdb) q

Na linha 42, X1 é carregado com o endereço da variável limite. Na linha 43 o valor em X0 é escrito nesse endereço de variável. Uma inspeção do valor em X0 (ir x0) mostra que o valor é 0x12 (18). Se o valor do limite for verificado antes da linha 43 ser executada, o resultado será 0 (p (int)limit -> $3=0). Quando a linha 43 é executada e o valor no limite é verificado novamente, é 18 (p (int)limit -> $4=18). As linhas 45 e 46 são executadas e quando o limite é verificado novamente ainda é 18 (p (int)limit -> $6=18).

Quando a linha 47 é executada (o comando é STR X1, [X0]) que deve armazenar o valor 2 na variável factor, o valor armazenado em limit é zerado (p (int)limit -> $7=0).

Como a linha 47 perturba o valor em =limit quando X0 foi carregado com o endereço para =factor?

Estou brincando com grandes listas para testar um cluster RPi. Estou construindo uma lista de cadeias de caracteres das quais eventualmente calcularei hashes para simular a mineração de criptomoedas. O código está sendo executado em um Raspberry Pi 3B Rev 1.2.

O código para construir a lista é:

from pympler import asizeof
import itertools
import time

start = time.process_time()
combos = list(itertools.combinations_with_replacement('abcdefghijlkmnopqrstuvwxyz', 6))
stop = time.process_time()
print(len(combos), asizeof.asizeof(combos)/1e6, (stop-start))

Os resultados são:

andrew@master:~ $ python mem_test_1.py 
736281 70.727904 0.68859771

O problema é que o tempo real (usando um cronômetro) está próximo de 45 segundos. Essa diferença de tempo é reproduzível ao executar o código no meu macbook M2 (números diferentes, mas ainda uma grande discrepância). Também tentei time.time() e time.perf_counter() com os mesmos resultados.

Para onde vai todo o tempo perdido e o que eu perdi?

Tenho tentado entender melhor como o Python aloca memória para listas quando a lista está sendo estendida por meio de acréscimos. Esta questão cobre bem o básico e explica que os incrementos de memória aumentam de tamanho à medida que o comprimento da lista aumenta. Este artigo é uma explicação do código fonte que pode ser encontrado aqui .

Eu quero perguntar sobre esta explicação:

/* This over-allocates proportional to the list size, making room
 * for additional growth.  The over-allocation is mild, but is
 * enough to give linear-time amortized behavior over a long
 * sequence of appends() in the presence of a poorly-performing
 * system realloc().
 * Add padding to make the allocated size multiple of 4.
 * The growth pattern is:  0, 4, 8, 16, 24, 32, 40, 52, 64, 76, ...
 * Note: new_allocated won't overflow because the largest possible value
 *       is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
 */
new_allocated = ((size_t)newsize + (newsize >> 3) + 6) & ~(size_t)3;
/* Do not overallocate if the new size is closer to overallocated size
 * than to the old size.
 */

E especificamente, este cálculo:

novo_allocado = ((tamanho_t)novotamanho + (novotamanho >> 3) + 6) & ~(tamanho_t)3;

Meu entendimento deste cálculo é que a nova alocação de memória será igual ao newsize (o tamanho atual que desencadeia o aumento) + o newsize rolado à direita de três bits (uma divisão efetiva por oito) + 6. Isso é então ANDed com o complemento de 1 de 3, então os dois últimos bits são forçados a zero para tornar o valor divisível por 4.

Usei esse código para gerar minhas listas e informar os tamanhos:

a = [i for i in range(108)]
print(sys.getsizeof(a))  # 920 bytes

b = [i for i in range(109)]
print(sys.getsizeof(b))  # 1080 bytes

Aos 109 elementos o redimensionamento é acionado e o novo tamanho agora é igual a 928 bytes

O cálculo acima deve ficar assim:

1.048 bytes é menor que o tamanho relatado de 1.060 bytes.

A documentação afirma que este processo pode não funcionar bem com listas pequenas, então tentei uma lista maior. Não vou reproduzir isso em binário.

a = [i for i in range(10640)]
print(sys.getsizeof(a))  # 85176 bytes

b = [i for i in range(10641)]
print(sys.getsizeof(b))  # 95864 bytes

[85184 + (86184 >> 3) + 6] = 95838 bytes

Isso cairá para 95836 quando "& ~3" for aplicado. Novamente, aquém dos 95.864 relatados.

Por que o redimensionamento relatado é maior que o redimensionamento calculado?