π
<-
Chat plein-écran
[^]

QCC 2021 Universel épisode 5: Python et tas (heap)

QCC 2021 Universel épisode 5: Python et tas (heap)

Unread postby critor » 16 Aug 2021, 16:27

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 5 - Python et tas (heap)

5409Pour fêter les 10 ans de
TI-Planet
en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée
QCC
organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
  • toutes les calculatrices graphiques
    Texas Instruments
    (depuis la première
    TI-81
    de 1990)
  • toutes les calculatrices graphiques
    Casio
    à technologie
    Flash
    (depuis 2003)
Ce qui donne pas moins de
132
modèles différents de calculatrices testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic ! :D

Les interpréteurs
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires :
  • La mémoire de stockage comme son nom l'indique stocke physiquement tes scripts
    Python
    .
  • La pile
    (stack)
    référence, à l'exécution, les objets
    Python
    créés. Sa capacité limite donc le nombre d'objets
    Python
    pouvant coexister simultanément en mémoire.
  • Le tas
    (heap)
    stocke, à l'exécution, le contenu des objets
    Python
    créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.

Aujourd'hui nous allons donc nous intéresser au
heap
. Cet espace est extrêmement important et surtout sur les plateformes nomades, car contrairement à d'autres langages les objets
Python
les plus simples ont le défaut d'être assez gros. Ce sera bien souvent le
heap
le facteur le plus limitant pour tes projets
Python
, d'où son caractère essentiel.

Le temps de construire notre protocole de test, concentrons-nous sur la
TI-83 Premium CE Edition Python
.

Nous avons justement la chance ici de disposer du module
gc
(garbage collector - ramasse miettes)
, avec plusieurs fonctions bien utiles :
  • gc.collect() pour nettoyer le
    heap
    en supprimant les valeurs d'objets
    Python
    qui ne sont plus référencées
  • gc.mem_alloc() pour connaître la consommation du
    heap
    en octets
  • gc.mem_free() pour connaître l'espace
    heap
    disponible en octets

Exécutons donc le petit script suivant afin de découvrir la capacité
heap
Python
de la
TI-83 Premium CE Edition Python
:
Code: Select all
import gc
a, f = gc.mem_alloc(), gc.mem_free()
(a, f, a + f)


Nous avons donc sur
TI-83 Premium CE Edition Python
une capacité
heap
de
19,968 Ko
.

Mais lorsque l'on accède à l'environnement
Python
, nombre de choses sont initialisées et ce
heap
n'est pas vide. Plus que
17,104 Ko
de libres.

Précisons que cet espace libre a de plus ici été amputé de par notre importation du module
gc
. Ce module n'étant hélas disponible que sur une minorité de
Pythonnettes
, il va nous falloir procéder autrement, surtout si l'on souhaite obtenir des mesures comparables.

Donnons quelques éléments de taille en mémoire d'objets
Python
usuels, du moins sur les plateformes 32 bits que sont nos calculatrices :
  • pour un entier nul :
    24
    octets déjà...
  • pour un entier court non nul
    (codable sur 31 bits + 1 bit de signe)
    :
    28
    octets
  • pour un entier long :
    • 28
      octets
    • +
      4
      octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
  • pour une chaîne :
    • 49
      octets
    • +
      1
      octet par caractère
  • pour une liste :
    • 64
      octets
    • +
      8
      octets par élément
    • + les tailles de chaque élément

Voici une fonction qui retourne la taille d'un objet selon ces règles :
Code: Select all
def size(o):
  t = type(o)
  s = t == str and 49 + len(o)
  if t == int:
    s = 24
    while o:
      s += 4
      o >>= 30
  elif t == list:
    s = 64 + 8*len(o)
    for so in o:
      s += size(so)
  return s


Nous allons donc tenter plutôt de remplir le
heap
avec plusieurs objets que nous allons faire grandir chacun son tour jusqu'à déclenchement d'une erreur, et retourner la capacité maximale que nous avons réussi à consommer. Voici donc un script en ce sens :
Code: Select all
def mem(v=1):
  try:
    l=[]
    try:
      l.append(0)
      l.append(0)
      l.append("")
      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)
      except:
        pass
      return l[0]
  except:
    return 0


Exécuter ce script va ainsi nous permettre d'évaluer équitablement tous les modèles.

L'appel mem(0) semble marcher comme souhaité, retournant une valeur qui peut comme prévu légèrement dépasser les
17,104 Ko
trouvés plus haut.

Mais voilà autre petit problème, le résultat n'est pas toujours le même, dépendant en effet de l'état du
heap
lors de l'appel. Rien que sur les résultats ci-contre, nous avons une marge d'erreur de 1 à 2%.

C'est beaucoup, en tous cas suffisamment pour inverser injustement des modèles au classement. Or nous tenons à être aussi précis que possible, afin justement de produire un classement aussi équitable que possible. ;)

Certes, on pourrait nettoyer le
heap
avant chaque appel avec gc.collect(), mais ce ne serait pas juste puisque nous n'aurons pas cette possibilité sur nombre de modèles concurrents. Il nous faut donc trouver autre chose.

Précisons que l'absence du module
gc
et donc de gc.collect() ne signifie absolument pas que le
heap
ne sera jamais nettoyé. C'est juste que nous ne contrôlons pas le moment où il le sera.

Et bien voici l'élément final du protocole de test que nous te proposons, avec une boucle répétant des appels mem(0), ce qui devrait finir par déclencher des nettoyages du
heap
, et te signalant à chaque fois que la valeur retournée bat ainsi un nouveau record :
Code: Select all
def testmem():
  m1, m2 = 0, 0
  while 1:
    t1, t2 = mem(0)
    if t1 > m1 or t2 > m2:
      m1 = max(t1, m1)
      m2 = max(t2, m2)
      input(str((m1,m2)))


Sur les
TI-83 Premium CE Edition Python
et
TI-84 Plus CE-T Python Edition
, nous pouvons donc exploiter jusqu'à
17,601 Ko
de
heap
.

C'est extrêmement faible, tes projets
Python
ne pourront pas aller bien loin ! :mj:

Prenons maintenant l'ancienne
TI-83 Premium CE
munie du module externe
TI-Python
interdit aux examens français, mais restant utilisable en classe ainsi qu'aux évaluations si l'enseignant le permet.

Ce n'est pas la panacée mais c'est quand même sensiblement mieux, avec
19,496 Ko
. Cela s'explique par l'absence de nombre de modules rajoutés dans le contexte de la
TI-83 Premium CE Edition Python
, dont les modules de tracé.

Conscient du problème de sous-dimensionnement de ce
heap
, a développé un
firmware
tiers
pour le module externe
TI-Python
.
Attention, il n'est toutefois utilisable qu'avec des calculatrices en version
5.3.5
,
Texas Instruments
ayant rajouté des protections pour interdire cela depuis.

Si tu l'installes tu bénéficieras donc d'un espace
heap
disponible nettement amélioré, avec
22,158 Ko
.

C'est donc au-delà de la capacité
heap
de
19,968 Ko
trouvée plus haut pour le
firmware
officiel, mais c'est normal puisque l'on se rend compte que
Lionel
a en effet passé la capacité
heap
à
22,912 Ko
.

La nouvelle
TI-82 Advanced Edition Python
de cette rentrée 2021 offre quant à elle
19,700 Ko
.

Encore une fois, cette amélioration cache en réalité l'absence de nombre de modules.

Arrive maintenant la
NumWorks
. Avec le
firmware
officiel
Epsilon
, elle nous offre
32,571 Ko
de
heap
.

Nous sommes certes moins à l'étroit que sur les modèles précédents, il y a de quoi commencer à aborder des projets un peu plus gourmands en ressources, mais pas aller très loin non plus.

Sous conditions, tu as la possibilité d'installer très facilement le
firmware
tiers
Omega
qui t'offrira pour sa part pas moins de
98,928 Ko
de
heap
! :bj:
Attention toutefois, le constructeur a décidé de t'interdire cette possibilité. Si ta machine vient avec une version
16.3+
du
firmware
officiel
Epsilon
, ou est mise à jour avec une de ces versions, elle sera verrouillée contre l'installation de
firmwares
tiers, et ce à notre connaissance à ce jour sans aucun retour possible. :#non#:

Avec la
Casio Graph 35+E II
, nous avons enfin d'origine quelque chose de très correct, pas moins de
100,432 Ko
de
heap
! :bj:

Il existe aussi une application
Python
tierce pour les
Casio Graph
monochromes, . Elle est compatible avec les modèles suivants, mais hélas bloquée par le mode examen :

1275312750Sur les deux premiers nous nous envolons à pas moins de
257,026 Ko
! :bj:

En effet selon le module
gc
, la capacité
heap
a ici été réglée à
258,048 Ko
.
1275212749Hélas, un bug toujours pas corrigé depuis l'année dernière fait que
CasioPython
reconnaît bêtement la
Graph 35+E II
comme un ancien modèle, n'y réservant alors qu'une capacité
heap
de
32,256 Ko
. :'(

Nous n'obtenons alors qu'un espace
heap
libre de
31,163 Ko
, ici donc sans aucun intérêt par rapport à l'application
Python
officielle. :#non#:

La
Casio Graph 90+E
nous met maintenant littéralement en orbite avec un formidable
1032,967 Ko
soit
1,033 Mo
, de quoi développer des projets absolument fantastiques ! :#tritop#:

Les
TI-Nspire CX II
sont encore plus extraordinaires.
2051,137 Ko
, soit
2,051 Mo
de
heap
, pour des projets
Python
absolument formidables ! :#tritop#:

Sur les
TI-Nspire CX
, tu peux installer l'application qui intègre un interpréteur
Micropython
.

Nous avons donc par défaut
1024,540 Ko
de
heap
, soit
1,025 Mo
! :#tritop#:

KhiCAS
intègre de plus son propre mode examen que tu peux activer depuis ses menus. Parfaitement compatible avec celui de
Texas Instruments
, ce mode examen a le gros avantage de laisser
KhiCAS
disponible ! :bj:

Attention toutefois, le mode examen de
KhiCAS
n'est pas compatible avec les
TI-Nspire CX II
.

De plus, l'installation de
Micropython
nécessite .

À ce jour
Ndless
n'est pas installable sur les
TI-Nspire CX II
et
TI-Nspire CX
munies des dernières mises à jour
5.3.2
ou
4.5.5
, et il n'y a aucun moyen de revenir à une version précédente.

En théorie
KhiCAS
permet de configurer la taille du
heap
. Cela semblait marcher sur des versions précédentes, mais apparemment ce n'est plus le cas sur les dernières versions. Toute modification même infime de la taille par défaut nous amène très rapidement à des plantages avant même d'avoir réussi à exécuter notre script.

Dommage, pour le moment nous ne pourrons donc pas en tenir compte cette année. :'(

Les
TI-Nspire CM
et
TI-Nspire
monochromes n'ont que
32 Mio
de mémoire
SDRAM
, ce qui n'est pas suffisant pour
KhiCAS
. À la place on peut prendre qui nous fait littéralement quitter l'attraction terrestre avec pas moins de
2049,201 Ko
soit
2,049 Mo
! :#tritop#:

En creusant un petit peu grâce au module
gc
ici disponible, nous découvrons que la capacité
heap
est de
2,049 Mo
.

Attention, l'installation de
Micropython
nécessite .

À ce jour
Ndless
n'est pas installable sur les
TI-Nspire CX II
et
TI-Nspire CX
munies des dernières mises à jour
5.3.2
ou
4.5.5
, et il n'y a aucun moyen de revenir à une version précédente.

De plus,
Micropython
disparaîtra en mode examen.

Et enfin il y a la
HP Prime
. Ah la
HP Prime
... ici nous ne sommes plus en orbite mais déjà dans une galaxie lointaine, très lointaine...

Distinguons les
HP Prime G1
avec
32 Mio
de
SDRAM
, et
HP Prime G2
avec
256 Mio
de
SDRAM
, testées toutes deux juste après un
reset
:
  • La
    HP Prime G1
    offre
    1020,293 Ko
    de
    heap
    , soit
    1,020 Mo
  • La
    HP Prime G2
    offre
    1023,804 Ko
    de
    heap
    , soit
    1,024 Mo
Par contre, la capacité du
heap
est ici réglable via
Shift
Plot
.
  • Sur pas moins de 3
    HP Prime G1
    , on arrive à régler très exactement jusqu'à
    16127 Ko
    avant plantage. :#tritop#:
  • Sur
    HP Prime G2
    , on arrive à régler à peine davantage, jusqu'à
    16384 Ko
    , un
    bug
    nous interdisant de régler des valeurs supérieures via cette boîte de dialogue.

Mais ne nous avouons pas encore vaincus. Les
HP Prime
permettent d'exécuter des scripts et fonctions
Python
depuis l'éditeur de programmes historique grâce à la fonction
PYTHON()
. Or, il se trouve que cette fonction permet de spécifier la capacité
heap
à allouer : PYTHON({nom_python,taille_heap},...).

Réalisons de quoi saisir et tester des capacités :
Code: Select all
#python heaptest_python
from gc import mem_alloc,mem_free
a,f=mem_alloc(),mem_free()
print("allocated heap: "+str(f+a))
print("free heap: "+str(f))
#end

Export heaptest_ppl(v)
Begin
  PRINT("allocating heap: "+v);
  PRINT("");
  PYTHON({heaptest_python,v});
End;


La
HP Prime G2
nous permet ainsi de spécifier jusqu'à 258 Mo et quelques, en pratique restons sur 258 Mo.

La capacité
heap
alors réellement reportée par le module
gc
est d'environ
252,1 Mo
! :#tritop#:

Les mesures sont facilement comparables sur le lien ci-dessous, et même disponibles pour bien d'autres modèles plus anciens :

  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,051 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 100,432 Ko
    :
    Casio Graph 35+E II
  6. 32,571 Ko
    :
    NumWorks
  7. 19,700 Ko
    :
    TI-82 Advanced Edition Python
  8. 17,601 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,051 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 1,025 Mo
    :
    TI-Nspire CX
  6. 100,432 Ko
    :
    Casio Graph 35+E II
  7. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  8. 64,954 Ko
    :
    NumWorks N0110
    (firmware Delta / Omega + appli KhiCAS)
  9. 32,571 Ko
    :
    NumWorks
  10. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  11. 19,700 Ko
    :
    TI-82 Advanced Edition Python
  12. 17,601 Ko
    :
    TI-83 Premium CE Edition Python
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,051 Mo
    :
    TI-Nspire CX II
  4. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  5. 100,432 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  6. 32,571 Ko
    :
    NumWorks
  7. 19,496 Ko
    :
    TI-83 Premium CE + TI-Python
  8. 19,700 Ko
    :
    TI-82 Advanced Edition Python
  9. 17,601 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
  1. 252,1 Mo
    :
    HP Prime G2
  2. 15,6 Mo
    :
    HP Prime G1
  3. 2,051 Mo
    :
    TI-Nspire CX II
  4. 2,049 Mo
    :
    TI-Nspire
  5. 1,033 Mo
    :
    Casio Graph 90+E / fx-CG50
  6. 1,025 Mo
    :
    TI-Nspire CX / CX II
  7. 257,026 Ko
    :
    Casio Graph 35/75+E / 35/75/95 / fx-9750/9860GII
    (SH4 - appli CasioPython)
  8. 100,432 Ko
    :
    Casio Graph 35+E II / fx-9750/9860GIII
  9. 98,928 Ko
    :
    NumWorks
    (firmware Omega)
  10. 64,954 Ko
    :
    NumWorks N0110
    (firmware Omega + appli KhiCAS)
  11. 32,571 Ko
    :
    NumWorks
  12. 32,256 Ko
    :
    Casio Graph 35+E II / 35/75/85/95
    (SH3)
    / fx-9750/9860GIII / fx-9750/9860GII
    (SH3)
    / fx-9860G
    (appli CasioPython)
  13. 25,235 Ko
    :
    NumWorks N0110
    (firmware Delta)
  14. 22,158 Ko
    :
    TI-83 Premium CE + TI-Python
  15. 19,496 Ko
    :
    TI-83 Premium CE + TI-Python
  16. 19,700 Ko
    :
    TI-82 Advanced Edition Python
  17. 17,601 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE Python Edition
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.5%
 
Posts: 38822
Images: 11334
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: QCC 2021 Universel épisode 5: Python et tas (heap)

Unread postby DJ Omnimaga » 18 Aug 2021, 00:56

17,601 Ko : TI-83 Premium CE Edition Python


Pendant ce temps, 150 Ko de RAM de disponible lors de l'exécution de programmes TI-BASIC et possibilité de jeux de 3 Mo sans biliothèque ASM/C. :troll:
User avatar
DJ OmnimagaPremium
Niveau 11: LV (Légende Vivante)
Niveau 11: LV (Légende Vivante)
Level up: 60.6%
 
Posts: 524
Images: 23
Joined: 21 Feb 2012, 12:04
Location: Quebec, Canada
Gender: Male
Calculator(s):
Class: Diplômé Secondaire (11ème année scolaire terminé)
YouTube: DJOmnimaga
Twitter: DJOmnimaga
Facebook: djomnimaga.music

Re: QCC 2021 Universel épisode 5: Python et tas (heap)

Unread postby critor » 22 Aug 2021, 13:37

Hors de France, on commence à se rendre compte combien on est à l'étroit en
Python
sur
NumWorks
: :P
https://www.reddit.com/r/numworks/comme ... ts_please/
(à l'historique de ses messages, cela me semble être un allemand)


Surtout depuis le blocage d'
Omega
. Plus moyen d'avoir
100K
de
heap
comme sur les
Casio Graph 35+E II
et
fx-9750/9860GIII
. :'(

C'est
32K
de
heap
avec
Epsilon
et rien d'autre. :mj:
Ce n'est pas assez, cela fait depuis 2017 que l'on râle contre le
heap
Python
de la
NumWorks
.

Au cas où il ne se soit pas encore fait définitivement piéger avec la mise à jour
v16
, j'ai répondu d'installer
Omega
. Ce n'est pas de la pub, c'est une réponse à un besoin, pour lequel il n'existe à ce jour et à ma connaissance aucune autre solution si ce n'est de passer à la concurrence TI/Casio/HP. Vais-je être censuré à votre avis ? :P
Image
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 24.5%
 
Posts: 38822
Images: 11334
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti
GitHub: critor

Re: QCC 2021 Universel épisode 5: Python et tas (heap)

Unread postby Adriweb » 22 Aug 2021, 15:21

Peut-etre faut-il faire un fork d'epsilon 15.x juste avec l'agrandissement du heap :P
Image
MyCalcs
: Help the community's calculator documentations by filling out your calculator info!
MyCalcs
: Aidez la communauté à documenter les calculatrices en donnant des infos sur votre calculatrice ![/url]
Inspired-Lua.org
: All about TI-Nspire Lua programming
User avatar
AdriwebAdmin
Niveau 16: CC2 (Commandeur des Calculatrices)
Niveau 16: CC2 (Commandeur des Calculatrices)
Level up: 71.6%
 
Posts: 13681
Images: 1107
Joined: 01 Jun 2007, 00:00
Location: France
Gender: Male
Calculator(s):
Twitter: adriweb
GitHub: adriweb


Return to News Divers

Who is online

Users browsing this forum: No registered users and 20 guests

-
Search
-
Social
-
Featured topics
Concours de l'Avent 2021 "l'énigme des 3 portes". Viens prendre connaissance des indices et bouts de code Python chaque jour. Sois parmi les 7 premiers à trouver et franchir l'une des 3 portes pour remporter de superbes lots : équipements complets en calculatrices Python couleur et/ou accessoires exclusifs !
Concours Geometry Dash - 2 équipements complets en calculatrices TI (+ goodies et accessoires) à gagner pour les 2 meilleurs niveaux créés
Concours de dessin de Noël 2021 Jusqu'au 7 janvier 2022 inclus par Casio. Dessine ta liste au Père Noël sur calculatrice/émulateur Graph 90/35+E II en Python ou fx-92+ Spéciale Collège. Ouvert aux élèves et enseignants, classement séparé. À gagner 2 consoles Nintendo Switch, 2 trottinettes électriques, 10 calculatrices Graph 90/35+E II au choix, 72 montres Casio G-Shock ou Vintage. Pas de perdant, goodies Casio pour tous les autres !
Coque NumWorks édition limitée Décembre 2021 à gagner.
Comparaisons des meilleurs prix pour acheter sa calculatrice !
12345
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
660 utilisateurs:
>637 invités
>16 membres
>7 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)