Forum TI-Planet.org

Argh. C'est à ce point-là, la différence de performances ?
Je n'ai pas touché au code d'init et à la fréquence CPU, donc je suppose que ce n'est pas parce que la board est mal réglée que les performances semblent si horribles.

Je note que sys.maxsize a été réduit.
Or, comme il n'y a pas d'entiers longs, cela réduit donc encore davantage l'intervalle des entiers supportés.

sys.maxsize==2147483647 sur NumWorks, Graph 90+E et Graph 35/75+E.
sys.maxsize==1073741823 sur le module externe TI-Python avec son firmware d'origine
sys.maxsize==536870911 sur le module externe TI-Python avec le dernier firmware de Lionel

OK, alors je vais essayer d'utiliser MICROPY_OBJ_REPR_A plutôt que MICROPY_OBJ_REPR_B, parce que cette représentation laisse un bit de plus pour les entiers, comme MICROPY_OBJ_REPR_C

EDIT: le .uf2 en pièce jointe (dans un tarball car l'extension .uf2 est interdite). Le seul changement depuis le diff précédent est donc -MICROPY_OBJ_REPR_B +MICROPY_OBJ_REPR_A dans ports/atmel-samd/mpconfig.h . La taille diminue très légèrement.

Je suis en train d'organiser un peu mon travail en local, pour une diffusion ultérieure sur Github et aussi au moins une PR à CircuitPython, puisque j'ai vu une paire d'optimisations mineures au passage

EDIT2: la PR est donc https://github.com/adafruit/circuitpython/pull/1527 .

Voilà, mis à jour le script de test de performances avec des entiers courts :

Code: Tout sélectionner

try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def genseed(ndigits):
  nmax,s,k=5*10**(ndigits-1),0,1
  while s<nmax:
    s+=k
    k*=2
  return s

def genarr(ndigits):
  sd,arr=genseed(ndigits),[]
  for k in range(1,ndigits):
    for j in range(ndigits):
      t=sd%10**k
      arr.extend([t,-t,10**k-t,t-10**k])
      sd=sd//10+(sd%10)*10**(ndigits-1)
  arr.extend([sd,-sd])
  return arr

def sortarr(arr,sdiff):
  segs=[0,len(arr)-1]
  while len(segs):
    iref=segs[0]
    for k in range(segs[0],segs[1]+1):
      if sdiff*(arr[k]-arr[iref])>0:
        t=arr[iref]
        arr[iref]=arr[k]
        arr[k]=arr[iref+1]
        arr[iref+1]=t
        iref+=1
    if iref>=segs[0]+2:
      segs.extend([segs[0],iref-1])
    if iref<=segs[1]-2:
      segs.extend([iref+1,segs[1]])
    segs.pop(0)
    segs.pop(0)
  return arr

def test(l,n):
  timed=hastime()
  start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
  arr.extend(genarr(l))
  for k in range(n):
    arr.extend(sortarr(arr,sdiff))
    sdiff=-sdiff
  stop=timed and monotonic() or 1
  return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]

Ligne d'appel : test(9,2)

1. TI-Nspire :1.41s
2. TI-Nspire CX CR3- : 1.56s
3. TI-Nspire CX CR4+ : 2.40s
4. NumWorks : 3.74s
5. Graph 90+E : 4.75s
6. HP Prime G2 : 8.81s
7. Graph 75+E + CasioPython : 9.78s
8. HP Prime G1 : 20.73s
9. module externe TI-Python (firmware d'origine) : 23.20s
10. Graph 90+E + KhiCAS : 60.71s

Adriweb: il y a un support partiel du short if, mais pas comme ca dans des expressions avec parentheses, ca aurait trop d'effets de bord d'essayer de gerer ca au niveau du lexer/parser. Je ne compte pas retravailler la-dessus, sinon c'est sans fin, d'autant plus que chaque nouvelle version de Python introduit probablement de nouvelles possibilites.

critor: bien joue pour le dernier script. Par contre je n'ai aucune idee de ce qu'il peut bien faire.

De maniere generale, je pense qu'il serait plus significatif de comparer des programmes faisant la meme chose mais tirant parti des particularites de chaque implementation. Evidemment, c'est plus systematique d'avoir un meme programme pour tous, mais d'un autre cote ca ne represente pas un usage normal de creer une fonction signe maison quand on en a une native sous la main. La force de KhiCAS/Xcas c'est de proposer beaucoup de fonctions mathematiques natives, sa faiblesse c'est qu'un evaluateur symbolique (autorisant l'evaluation d'une variable libre) est significativement plus lent qu'un evaluateur non symbolique. Il est assez clair que tous les benchmarks systematiques vont classer les implementations a base de Xcas en queue de classement, alors que pour un etudiant voulant programmer en relation avec les maths, l'environnement est bien plus riche et sera plus rapide lorsqu'on peut utiliser une fonction native specifique.

parisse a écrit:critor: bien joue pour le dernier script. Par contre je n'ai aucune idee de ce qu'il peut bien faire.

Rien de bien intéressant, à part occuper suffisamment de temps processeur pour pouvoir faire un classement.

Il génère une liste puis la trie alternativement par ordre croissant et décroissant, et concatène le résultat à chaque fois.

Je n'ai volontairement pas utilisé la fonction sort() de Python, car le fonctionnement interne peut différer d'une plateforme à une autre selon les optimisations autorisées à la compilation.

Donc pour un QCC 2019, nous avons maintenant 2 tests de performances Python :

• un avec uniquement des entiers courts
• un avec uniquement des flottants

critor a écrit:Voilà, mis à jour le script de test de performances avec des entiers courts

Voici une amélioration qui est globale aux scripts de tests:

plutot que d'incorporer directement le benchmark a l'interieur de la fonction, on cree une fonction a part, comme ca on a juste a implémenter la fonction à tester normalement
beaucoup plus naturel, réutilisable, et propre

Pour ton exemple ci-dessus, le coeur de la fonction test est la meme, mais j'ai une autre fonction timefunc qui prend la fonction à benchmarker en parametre, ainsi que ses arguments.

Code: Tout sélectionner

def test(l, n):
    sdiff, arr = -1, []
    arr.extend(genarr(l))
    for k in range(n):
        arr.extend(sortarr(arr, sdiff))
        sdiff = -sdiff
    return len(arr), arr[0], arr[len(arr) // 2 - 1], arr[len(arr) // 2], arr[len(arr) - 1]


def timefunc(func, *args):
    timed = hastime()
    start, stop = 0 or timed and monotonic(), 1
    retvals = (func(*args))
    stop = timed and monotonic() or 1
    return stop - start, retvals


print(timefunc(test, 9, 2))

Et puis, bonus visuellement, puisque dans le print ca cloisonne un peu mieux le temps de la retval de la fonction. par exemple :

Code: Tout sélectionner

/usr/bin/python3 test.py
(0.020823007998842513, (1160, 536870911, -536870911, 536870911, -536870911))

Edit: Maintenant, il faudrait probablement voir comment avoir quelque chose de compatible avec la syntaxe giac... (je suppose qu'il y aurait moyen, quitte a faire un if(giac) dans la fonction timefunc).

Plutot que d'essayer a tout prix de faire une fonction timefunc qui marche aussi pour giac, il me semble beaucoup plus simple de juste faire time(test(9,2)).

parisse a écrit:Plutot que d'essayer a tout prix de faire une fonction timefunc qui marche aussi pour giac, il me semble beaucoup plus simple de juste faire time(test(9,2)).

?
test(9,2) sera évalué avant que la fonction time soit appelée avec le résultat de la fonction test, donc je ne vois pas comment la fonction time pourrait mesurer quoi que ce soit.
(sauf si "time" est quelque chose de particulier en giac, auquel cas, pourquoi pas...)

Edit: oui ok, c'est bien le cas, c'est specifique a giac. Donc encore plus simple. Dispo sur KhiCAS etc. ?

(PS: Je n'ai pas trouvé de moyen de déclarer une fonction variadique en giac, voir de passer une fonction en parametre a une autre fonction - est-ce possible ? Meme si ce n'est plus d'actualité)

Salut à tous,

J'essaye d'executer le script avec Khicas, mais j'obtiens system error address target DF1ED41F, pc=000000000
Khicas version de janvier. Bizarre

Adriweb a écrit:

critor a écrit:Voilà, mis à jour le script de test de performances avec des entiers courts

Voici une amélioration qui est globale aux scripts de tests:

plutot que d'incorporer directement le benchmark a l'interieur de la fonction, on cree une fonction a part, comme ca on a juste a implémenter la fonction à tester normalement
beaucoup plus naturel, réutilisable, et propre

Pour ton exemple ci-dessus, le coeur de la fonction test est la meme, mais j'ai une autre fonction timefunc qui prend la fonction à benchmarker en parametre, ainsi que ses arguments.

Code: Tout sélectionner

def test(l, n):
    sdiff, arr = -1, []
    arr.extend(genarr(l))
    for k in range(n):
        arr.extend(sortarr(arr, sdiff))
        sdiff = -sdiff
    return len(arr), arr[0], arr[len(arr) // 2 - 1], arr[len(arr) // 2], arr[len(arr) - 1]


def timefunc(func, *args):
    timed = hastime()
    start, stop = 0 or timed and monotonic(), 1
    retvals = (func(*args))
    stop = timed and monotonic() or 1
    return stop - start, retvals


print(timefunc(test, 9, 2))

Et puis, bonus visuellement, puisque dans le print ca cloisonne un peu mieux le temps de la retval de la fonction. par exemple :

Code: Tout sélectionner

/usr/bin/python3 test.py
(0.020823007998842513, (1160, 536870911, -536870911, 536870911, -536870911))

Edit: Maintenant, il faudrait probablement voir comment avoir quelque chose de compatible avec la syntaxe giac... (je suppose qu'il y aurait moyen, quitte a faire un if(giac) dans la fonction timefunc).