Discussion :

[Julien N]

Bonjour,

Admettons le code Fortran suivant (add_f.f90) :

Code :

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

1
2
3
4
5
6
7
8
9
10
function add(x, y)
 
    implicit none
 
    double precision             :: add
    double precision, intent(in) :: x, y
 
    add = x + y
 
end function add

Je peux le compiler en une library comme ceci :

Code :

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

1
2
gfortran -c -fno_underscoring add_f.90
gfortran -shared -fPIC -o add_f.so add_f.o

Je peux vérifier le contenu de la library :

Code :

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

1
2
3
4
5
6
nm -D add_f.so
00000000000010f9 T add
                 w __cxa_finalize
                 w __gmon_start__
                 w _ITM_deregisterTMCloneTable
                 w _ITM_registerTMCloneTable

Je souhaite maintenant appeler la fonction add depuis un script Python. Je me suis inspiré pour cela du sujet suivant : https://www.developpez.net/forums/d2.../#post11404304

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import ctypes
 
# Définition de la fonction add depuis la library
libf = ctypes.CDLL('add_f.so')
func = libf.add
 
# Définition du type des arguments et de la sortie
func.argtypes = [ctypes.c_double, ctypes.c_double]
func.restype = ctypes.c_double
 
# test
res = func(1.2, 3)
 
print(res)

Qui me renvoie un messagre d'erreur :

Code :

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

/tmp/geany_run_script_SE8FJ0.sh: line 7: 54151 Segmentation fault

Si je ne spécifie pas le type des arguments j'ai un message d'erreur de type TypeError.

Qu'est-ce qui est incorrect ici ?

J

[wiztricks]

Salut,

Quand je me lance dans des opérations inhabituelles, je cherche un peu sur Internet d'abord. Ce que je n'ai pas manqué de faire en lisant votre sujet. Ah ben ouais, on peut le faire sans trop de problèmes pourvu qu'on passe ses arguments par référence et qu'on fasse un peu attention aux variations dans les types.

- W

[Julien N]

Bonjour Wiztricks,

Je ne saisi pas en quoi mon exemple diffère des exemples que j'ai pu voir sur la doc de ctypes. Il me manque une pièce au puzzle.

Je me suis penché sur cette notion de "par référence" et "par valeur". Pour moi les arguments x et y ne doivent pas être passés par référence. Peut être la valeur de retour, add, doit l'être elle.

Mais si je teste :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
from ctypes import CDLL, POINTER, c_double
 
libf = CDLL('add_f.so')
func = libf.add
func.restype = POINTER(c_double)
 
# Test
res = func(c_double(1.2), c_double(3))
 
print(res)

J'obtiens un pointer <__main__.LP_c_double object at 0x7fac006a4ae8>. Et dès que j'essaie d'accéder à sa valeur par l'attribut .contents, je me retrouve avec un segfault à nouveau.

J

[wiztricks]

Salut,

Je ne saisi pas en quoi mon exemple diffère des exemples que j'ai pu voir sur la doc de ctypes. Il me manque une pièce au puzzle.

La documentation de ctypes vous explique juste comment charger une DLL, fabriquer les arguments des fonctions, les appeler,...

Elle ne vous dira pas que telle fonction de la DLL devra être appelée avec des arguments par référence ou par valeur. Et comme ctypes est plutôt orienté C, çà ne racontera pas grand chose non plus sur Fortran.

Après, si vous voulez réinventer la roue plutôt que de voir comment çà peut se faire en cherchant un peu sur Internet...

- W

[Julien N]

Croyez bien que si je pose une question c'est que je n'ai pas trouvé la réponse par moi-même. Il est plus facile de trouver une réponse lorsqu'on sait ce que l'on recherche. C'est pour cette raison que ma question initiale est :

Qu'est-ce qui est incorrect ici ?

Je ne vois pas en quoi je réinvente la roue en essayant de faire marcher un exemple simple destiné à comprendre comment cela fonctionne.

[wiztricks]

Je ne vois pas en quoi je réinvente la roue en essayant de faire marcher un exemple simple destiné à comprendre comment cela fonctionne.

Tous les exemples que j'ai trouvé disent (et montrent) qu'avec fortran, les arguments sont appelés par référence...

- W

[Julien N]

Navré d'avoir posé une question qui semble aussi évidente.

Au cas où quelqu'un se poserait la même question plus tard, je vais quand même décrire ci-dessous là je me suis arrêté. Je passe en résolu. Je vais chercher le bout qui me manque ailleurs.

Code Fortran (f90):

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
! Function to add two values
function add_f(x, y) result(res)
 
    implicit none
 
    double precision, intent(in) :: x, y
    double precision             :: res
 
    res = x + y
 
    print *, "Function add_f"
    print *, x
    print *, y
    print *, res
 
end function add_f
 
 
! Subroutine to add two values
subroutine add_s(res, x, y)
 
    double precision, intent(in) :: x, y
    double precision, intent(inout) :: res
 
    res = x + y
 
    print *, "Routine add_s"
    print *, x
    print *, y
    print *, res
 
end subroutine add_s

Une sousroutine additionnant deux réels dans une sortie nommée res, et une fonction additionnant deux réels et renvoyant res. res étant à chaque fois également un réel.

Je compile avec gfortran pour avoir une library nommée add.so:

Code :

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

1
2
gfortran -c -fPIC -fno_underscoring add_f.90
gfortran -shared -o add_f.so add_f.o

Je parviens à appeler la sous-routine add_s et récupérer le résultat comme suit :

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
import ctypes as ct
 
# Chargement de la librarie
libf = ct.CDLL('add.so')
 
# Definition des valeurs des arguments
x, y = ct.c_double(1.2), ct.c_double(3)
 
# Appel de la sous-routine. Nécessité de définir la variable de sortie
# car une sous-routine modifie une valeur, et non ne renvoie quelque chose.
# De plus, il est nécessaire de "référencer" la valeur par un pointer, de même
# pour les arguments d'entrée (soit avec byref soit avec pointer, au choix)
res = ct.pointer(ct.c_double(0.0))
_ = libf.add_s(res, ct.byref(x), ct.byref(y))
 
print(res[0])
 
>>> Routine add_s
>>>   1.2000000000000000     
>>>   3.0000000000000000     
>>>   4.2000000000000002     
>>>4.2

Par contre, bien que je parvienne à appeler la fonction add_f, je n'ai pas trouvé comment récupérer sa sortie :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import ctypes as ct
 
libf = ct.CDLL('add.so')
 
x, y = ct.c_double(1.2), ct.c_double(3)
 
# Appel de la fonction. Là également il faut référencer les arguments.
res = libf.add_f(ct.pointer(x), ct.pointer(y))
 
print(res)
 
>>> 0

Je reçois le code de sortie uniquement.

J

[Beginner.]

Salut,

Pourrais-tu nous donner ce qu'il faut pour qu'on puisse tester (la DLL...) ? Ca pourrait aider à aider lol...