Discussion :

[Madmac]

Ruby avec le même bogue dans ces première version
Noter la différence au niveau de la boucle entre les deux version. La première sans initialisation de la variable de boucle.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
julia> x = rand(1000);
 
julia> function sum_global()
                  s = 0.0
                  for i in x
                      s += i
                  end
                  return s
              end;
 
julia> function sum_global2()
                  s = 0.0
                  x2 = x
                  for i in x2
                      s += i
                  end
                  return s
              end;

Noter la différence de consommation de mémoire. Si on doit absolument utiliser une valeur globale, initialiser la valeur de la variable de boucle fait une différence.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
julia> @time sum_global()
  0.010457 seconds (7.70 k allocations: 296.413 KiB)
500.5470581312482
 
julia> @time sum_global()
  0.000177 seconds (3.49 k allocations: 70.156 KiB)
500.5470581312482
 
 
julia> @time sum_global2()
  0.000156 seconds (3.49 k allocations: 70.156 KiB)
500.5470581312482
 
julia> @time sum_global2()
  0.000152 seconds (3.49 k allocations: 70.156 KiB)
500.5470581312482

La version avec paramètre reste le meilleur choix

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
julia> function sum_arg(x)
                  s = 0.0
                  for i in x
                      s += i
                  end
                  return s
              end;
 
julia> @time sum_arg(x)
  0.008057 seconds (4.59 k allocations: 220.394 KiB)
500.5470581312482
 
julia> @time sum_arg(x)
  0.000003 seconds (1 allocation: 16 bytes)
500.5470581312482

Mais j'ai du mal à comprendre une telle différence de consommation de mémoire et de temps.

[danielhagnoul]

Permettez-moi de vous dire que vous n'écoutez pas les bons conseils, pas de variable globale. Le code soit toujours se trouver dans une fonction ou dans un module.
La première mesure du temps d'exécution prend en compte le temps de compilation.

Code Julia :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
function sum_global(x)
    s = 0.0
    for i in x
        s += i
    end
    return s
end
 
function sum_global2(x)
    s = 0.0
    x2 = x
    for i in x2
        s += i
    end
    return s
end
 
function main()
    x = rand(1000) # jamais de variable globale
 
    @time @show sum_global(x) # on mesure surtout le temps de compilation
 
    @time @show sum_global(x) # on mesure le temps d'exécution
    @time @show sum_global2(x) # on mesure le temps d'exécution
 
end
 
main()
 
#=
sum_global(x) = 479.06147390780353
  0.164044 seconds (409.03 k allocations: 21.682 MiB)
 
sum_global(x) = 479.06147390780353
  0.000262 seconds (16 allocations: 848 bytes)
  
sum_global2(x) = 479.06147390780353
  0.000298 seconds (16 allocations: 848 bytes)
=#

Code Julia :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
function sum_global(x)
    return sum(x)
end
 
function sum_global2(x)
    x2 = x
    return sum(x2)
end
 
function main()
    x = rand(1000) # jamais de variable globale
 
    @time @show sum_global(x) # on mesure surtout le temps de compilation
 
    @time @show sum_global(x) # on mesure le temps d'exécution
    @time @show sum_global2(x)
 
end
 
main()
 
#=
sum_global(x) = 504.55497213150574
  0.164240 seconds (409.03 k allocations: 21.683 MiB)
 
sum_global(x) = 504.55497213150574
  0.000143 seconds (16 allocations: 848 bytes)
  
sum_global2(x) = 504.55497213150574
  0.000300 seconds (16 allocations: 848 bytes)
=#

[dourouc05]

La doc explique ce qui se passe avec des variables globale : https://docs.julialang.org/en/v1/man...obal-variables.

[Madmac]

Permettez-moi de vous dire que vous n'écoutez pas les bons conseils, pas de variable globale.

Ce n'est pas, que je n'écoute pas. Mais que je cherche à comprendre la disparité de performances entre les deux. Dans le cas du module, comprend que cela ajoute une indirection à l'accès de la variable. Mais pour ce qui est de la différence entre les locales et les globales, je ne pige pas! L'accès à une valeur globale se fait toujours par un pointeur, ce qui normalement est plus rapide qu'un accès par valeur. Moi, ça m'intrigue!

[dourouc05]

Pourquoi un accès par pointeur serait-il plus rapide qu'un accès par valeur ? Un pointeur force à effectuer une indirection, contrairement à un passage par valeur.

As-tu lu le lien que j'avais envoyé ? Voici la partie intéressante :

A global variable might have its value, and therefore its type, change at any point. This makes it difficult for the compiler to optimize code using global variables.

Pour une variable globale, le problème n'est pas l'indirection, mais le fait qu'on a un pointeur vers "un truc Julia" (qui peut avoir n'importe quel type), plutôt qu'une valeur d'un type donné.

[Madmac]

Pourquoi un accès par pointeur serait-il plus rapide qu'un accès par valeur ? Un pointeur force à effectuer une indirection, contrairement à un passage par valeur.

Parce que un passage par valeur implique une recopie de la valeur dans la plupart des langages de programmation. Et c'est pour cette raison, que la plupart des langages de programmation ne permettent pas de l'usage un tableau comme argument de fonction. Et cela s'applique également au pointeur qui sont passés en argument. Mais comme les pointeurs sont de petite taille, le temps de copie est insignifiant. En n'ayant aucune faveur couplée avec l'extérieur de la fonction, on peut ainsi récupérer automatiquement la mémoire du contenu des variables à la fin de l'exécution d'une fonction. Et en bonus, on récupère des blocs de mémoire qui sont à des adresses de mémoires consécutives. Donc moins de fragmentation de mémoire! C'est une des meilleures technique de ramasse-miette pour les fonctions. Si la technique t'intéresse, explore le code de Xlisp :https://github.com/rsdoiel/xlisp.
C'est une version complète, avec un ramasse-miette inclus. Une vraie beauté pour étudier la fabrication d'un interpréteur.

Et c'est également en raison de la recopie que le programmeur doit favoriser l'usage de pointeur quand il programme en C ou en Pascal, Afin d'avoir les meilleurs performances.

Un pointeur force à effectuer une indirection, contrairement à un passage par valeur.

Le pointeur est la base du langage machine. C'est un référence à une adresse que le CPU peut lire directement. Quand ton code en C fonctionne entièrement avec des pointers, c'est comme programmer en langage machine. Le code contient uniquement des pointeurs, les valeurs que nous manipulons (les chiffres, les chaînes) sont généralement dans un espace distinct du code.