QCC 2019 épisode 5 : mémoire de travail & récursivité Python

[critor]

Quelle Calculatrice programmable Choisir 2019 - Episode 5
Mémoire de travail et récursivité Python

Revenons aujourd'hui au Python. Un autre point important concerne les ressources mises à disposition pour l'exécution des scripts.

La HP Prime ne sera pas classée aujourd'hui, ce n'est pas pertinent car elle ne dispose pas d'un véritable interpréteur Python et ne réagit pas correctement à nos tests. Toutefois elle ne sera pas pénalisée pour le classement final, n'arrivant pas à lui déterminer de limites exactes nous lui mettrons la note maximale pour ces tests.

Nous allons dans un premier temps tester la mémoire de travail à l'aide du script suivant :

Code: Select all

def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

L'appel mem() effectué juste après un redémarrage de la calculatrice nous renvoie les résultats suivants :

1. 2,049276 Mo : TI-Nspire + MicroPython
2. 1,032942 Mo : Casio Graph 90+E
3. 257,636 Ko : Casio Graph 35/75+E + CasioPython
4. 100,560 Ko : Casio Graph 35+E II
5. 31,899 Ko : Casio Graph 35+E II + CasioPython
6. 22,605 Ko : TI-83 Premium CE + TI-Python + firmware tiers
7. 20,200 Ko : TI-83 Premium CE Edition Python
8. 19,924 Ko : TI-83 Premium CE + TI-Python
9. 16,109 Ko : NumWorks N0100
10. 15,984 Ko : NumWorks N0110

Mais il n'y a pas que la mémoire dans la vie d'un script Python, il y a aussi la pile (stack). Nous allons maintenant partir sur un test de récursivité avec le script suivant :

Code: Select all

def sumr(n):
  if n<=0:
    return 0
  else:
    return n+sumr(n-1)

def maxr(fct):
  n=0
  try:
    while True:
      fct(n)
      n=n+1
  except Exception as e:
    print(e)
  return n

L'appel maxr(sumr) effectué là encore juste après un redémarrage de la calculatrice nous renvoie les résultats suivants :

1. 5362 : Casio Graph 35/75+E + CasioPython
2. 655 : Casio Graph 35+E II + CasioPython
3. 130 : TI-Nspire + MicroPython
4. 82 : Casio Graph 90+E / Casio Graph 35+E II
5. 29 : NumWorks
6. 23 : TI-83 Premium CE Edition Python
7. 20 : TI-83 Premium CE + TI-Python
8. 15 : TI-83 Premium CE + TI-Python + firmware tiers

On peut remarquer sur ce dernier test que les messages d'erreur ne sont pas toujours les mêmes; certains évoquent en effet la taille du stack et d'autres le nombre de récursions.



Si elles ne l'ont pas emporté la dernière fois pour la richesse des implémentations Python offertes, de façon générale, et encore plus si l'on s'en tient au mode examen, pour des scripts Python un tant soit peu ambitieux la bonne solution semble aujourd'hui être les Casio Graph 90+E et Casio Graph 35+E II.

Avant de conclure, une petite page de publicité pour l'une des plus grandes arnaques jamais sortie par un constructeur de calculatrices graphiques :

[ptijoz]

c'est un point noir pour les Numworks ces 16Ko pour Python.. Avec un nouveau modèle ils auraient pus l'augementer ! J'espère qu'ils vont vite corriger !

[critor]

Oh ils en ont de la mémoire, 256Kio de SRAM, mais ils ne l'affectent pas au Python.

[parisse]

Le tas specifique Python fait 16K sur la Numworks, ca pourrait facilement etre augmente sans changer la taille du tas de la machine car ce n'est pas l'app qui occupe le plus de place, sauf erreur regression prend une trentaine de K en plus.
Concernant KhiCAS, la limite de recursivite est fixee a 100, comme on peut facilement le tester par une definition recursive de la factorielle:

Code: Select all

u(n):=when(n==0,1,u(n-1)*n);
u(99);
u(100)


La memoire de travail utile est de l'ordre de 30K environ sur la graph 90 (on peut creer des matrices de taille 60 dans l'historique), deux fois moins sur la 35eii.

[critor]

Merci pour les précisions.
KhiCAS est donc, à la louche, comparable à l'appli Python de la Graph 35+E II.

[parisse]

En memoire brute oui, mais il me semble que l'utilisation de la memoire est plus parcimonieuse dans KhiCAS. Un entier court de 30 bits occupe 8 octets (pareil pour un flottant a 45 bits de mantisse), alors qu'il me semble d'apres votre script que c'est 24 octets en micropython. Une liste de n entiers courts occupe 32+n*8 en KhiCAS, contre semble-t-il 64+n*32. J'ai fixe la taille maximale de liste a 3000 sur la 90 et 1000 sur la 35, donc en matrices 54 et 31 mais je vais diminuer, car il faut qu'on puisse faire quelque chose d'utile (par exemple stocker la matrice et calculer son inverse ou ses valeurs propres) sans risquer un reboot.