Discussion :

[Peter57]

Salut � tous !
J'ai test� un petit programme test (somme d'un cos + sin dans une boucle de 1 000 000 d'it�rations) en Python, en Cython et enfin en 'C'.
le r�sultat est surprenant !
Quelque soit la fonction (j'ai test� un calcul de suite de Fibonacci), Python 3.13 est plus rapide que Cython ! le C quand � lui �crase tout le monde !
Avec n it�rations = 1 000 000
fonction test�e :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

s+= cos(i) + sin(i)

Somme cython: -0.06
Dur�e : 0.209480 sec

Somme python: -0.06
Dur�e : 0.159361 sec

Somme C : -0.06
Duree: 0.011000 sec

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !
Bien cordialement.
Peter

[Peter57]

Personne n'a un avis sur l'utilisation de Cython ?

[wiztricks]

Salut,

Apparemment pas la peine d'essayer de passer par Cython. Python 3.13 fait mieux !

Pour sortir ce genre d'affirmation, il faudrait un exemple plus significatif, un code montrant comment ont �t� obtenus ces r�sultats permettant de les reproduire au besoin.

- W

[fred1599]

Bonjour,

Peut-�tre aussi que vous comparez le temps d'ex�cution d'un code cpython (python d�j� optimis� avec wrapper C) avec votre code cython (code C fait maison).
Ce temps pourrait �tre logique, mais pour v�rifier, il nous faudra comme dit pr�c�demment par mon VDD, le code !

[wiztricks]

Personne n'a un avis sur l'utilisation de Cython ?

C'est un outil pour optimiser l'utilisation CPU/m�moire d'un code o� on a d�j� fait le n�cessaire c�t� algorithme.
Si vous pensez que �a devrait apporter quelque chose et que le r�sultat n'est pas l�, c'est que vous vous �tes plant� quelque part sur la pertinence � utiliser cet outil dans ce cas particulier (et on attends toujours les d�tails de ce que vous avez fait).

note: cython ne date pas d'hier et ceux qui l'utilisent � bon escient en sont g�n�ralement satisfait.

- W

[Peter57]

voila le programme python -cython

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#
#   fichier main.py
#
 
from pyximport import install ; install()
import cython_fn
import time
import python_fn
 
#iterations
n = 1000000
 
# cal cython version
t0 = time.time()
sum_cython = cython_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme cython: {sum_cython:.2f}")
print(f"Durée : {t:.6f}")
 
# calc python version
t0 = time.time()
sum_python = python_fn.cos_calc(n)
t1 = time.time()
 
t = t1-t0
print(f"Somme python: {sum_python:.2f}")
print(f"Durée : {t:.6f}")
 
#
#   fichier cython_fn.pyx
#
# cython : language_Level = 3
 
import math
 
def cy_fibo(int n):
    cdef int a,b,i
 
    a , b = 1, 1
 
    for i in range(n):
        a, b = a+b, a
    return a
 
# version cython
def cos_calc(int n):
    cdef double s = 0.0
    cdef int i=0
 
    for i in range(n):
        s += (math.cos(i) + math.sin(i))
 
    return s
 
#
#   fichier python_fn.py
#
 
import math
 
def cos_calc(n : int):
    s = 0.0
    for i in range(n):
        s += math.cos(i) + math.sin(i)
    return s

[Peter57]

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
20
21
22
23
24
25
26
27
28
29
30
31
 
// Cython vs Python
// C version
 
#include <stdio.h>
#include <time.h>
#include <math.h>
 
double cos_calc(int n) {
	double s = 0.0;
	for (int i = 0; i < n; i++) {
		s += (cos(i) + sin(i));
	}
	return s;
}
 
int main(){
	int n = 1000000;
	double s = 0.0;
 
	clock_t start = clock();
	s = cos_calc(n);
	clock_t end = clock();
 
	double duration = (double)(end - start) / CLOCKS_PER_SEC;
 
	printf("Somme: %.2f\n", s);
	printf("Duree: %.6f secondes\n", duration);
 
	return 0;
}

[Peter57]

Je concois que la biblioth�que 'Math' de Python 3.13 soit sans doute mieux optimis�e que celle de Cython pour le calcul de cos() et sin').
Mais j'obtiens des r�sultats similaires avec le calcul d'une suite de Fibonacci avec l'algorithme non recursif.

[fred1599]

Hello,


Pour ce genre de probl�matique (hors le cas de la suite de Fibonacci qui est un probl�me it�ratif), la vectorisation est � mon sens une meilleure solution. Je vous recommande de regarder du c�t� de numpy.
Le souci principal vient du fait que votre code Cython n'est pas optimis�. Vous effectuez de nombreux allers-retours entre les types C et les objets Python, ce qui a forc�ment un co�t en performance. La solution est de rester le plus possible dans les types C au sein de votre fonction Cython.
Pour cela, il faut utiliser les fonctions C de cosinus et sinus directement depuis la librairie math�matique C :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

from libc.math cimport cos, sin

Ensuite, le code Cython peut �tre encore optimis� � l'aide de d�corateurs (ou directives du compilateur) bien choisis qui �vitent certaines v�rifications de s�curit� de Python (co�teuses en temps) :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
import cython
 
 
@cython.boundscheck(False) # Désactive la vérification des bornes (utile si vous accédiez à un tableau)
@cython.wraparound(False)  # Désactive la gestion de l'indexation négative (ex: liste[-1])
def cos_calc(int n):
    # ... suite du code

M�me apr�s cette optimisation, le C pur sera probablement toujours un peu plus rapide. C'est normal, il n'y a aucune surcouche li�e � l'interpr�teur Python.

Pour conclure, au niveau des performances pour votre fonction cos_calc, numpy reste le meilleur choix. Avec Cython, vous �crivez une boucle for qui, bien que compil�e en C, traite les �l�ments un par un. � l'inverse, numpy transforme cette boucle en une s�rie d'appels � des fonctions C vectoris�es, qui sont bien plus performantes pour les calculs sur de grands tableaux de donn�es.

[wiztricks]

Je concois que la biblioth�que 'Math' de Python 3.13 soit sans doute mieux optimis�e que celle de Cython pour le calcul de cos() et sin').

Dans tous les cas, les fonctions sin et cos appel�es sont celles du math.h de la libc qui vient avec le compilateur C (puisque Python est �crit en C, on ne va pas r�-�crire les fonction de base).
note: il y a aussi de microprocesseurs qui proposent des acc�l�rateurs mat�riels qui passent peut �tre � c�t�.

On reprend votre code en ajoutant une petite fonction calc_sum qui estime le co�t de ce qui n'est pas sin(i)+cos((i)

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
from math import cos, sin
from time import time
 
def calc_trig(n):
    s = 0
    for i in range(n):
        s += sin(i) + cos(i)
    return s
 
def calc_sum(n):
    s = 0
    for i in range(n):
        s += i
    return s
 
def test(n, func):
    t0 = time()
    func(n)
    return time() - t0

Chez moi, j'obtiens:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
>>> a = test(1000000, calc_trig)
>>> b = test(1000000, calc_sum)
>>> a
0.10003924369812012
>>> b
0.024285078048706055
>>> b/a
0.24275551424587996
>>>>>> a - b
0.07575416564941406

A quelques petites impr�cisions pr�s, vu que Cython et Python utilisent les m�mes fonctions sin et cos, si on "acc�l�re" ce sera sur des instructions autres qui ne contribuent qu'� 25% du temps total.

Pour ce qui est du C, le compilateur peut s'amuser � utiliser des acc�l�rations mat�rielles (et optimiser aussi le calcul des fonctions). Il faudrait regarder le code machine/assembleur pour voir ce qu'il a produit... si �a vous tente.

- W

[Peter57]

Merci de ces renseignements !
Cordialement.
Peter.