handle python classes #1119

MostafaMamouni · 2022-05-30T12:27:24Z

MostafaMamouni
May 30, 2022
Collaborator

an initial conversation about supporting python classes in Pyccel. any ideas to be considered ?

EmilyBourne · 2022-06-02T12:43:34Z

EmilyBourne
Jun 2, 2022
Collaborator

It would be good to have a list of the different aspects of classes so it is clear:

What is already implemented
What should/could be added
What needs adding first
What (if anything) do we not plan to support (e.g. some magic methods)

0 replies

EmilyBourne · 2022-07-02T15:52:13Z

EmilyBourne
Jul 2, 2022
Collaborator

Things that are supported can be found in the tests:
https://github.com/pyccel/pyccel/tree/master/tests/pyccel/scripts/classes

There are also some tests for unsupported things:
https://github.com/pyccel/pyccel/tree/master/tests/codegen/fcode/scripts

Things to consider :

Name collisions, see discussion: Fixing name collisions in C #1149
Deallocation of objects with destructors stored in the class (class objects or arrays)

Things to add first:

Support in c for everything currently supported by fortran
Support for non-pointer arrays stored in classes (requires correct deallocation)

Things to add second:

cwrapper. This is complicated and can be broken into parts
- Create a struct containing a pointer to the class and the associated TypeObject (see tutorial). The TypeObject should contain references to the __init__ and __del__ functions. At this point it should be possible to create and destroy a class instance from python but not to interact with the created object.
  i.e the following should be possible after translating mod.py
```
from mod import MyClass
a = MyClass(1)
```
- Add functions to the class. This should be simple as it will be very similar to what is done for classes currently
- Add variables to the class using getters and setters (see docs)
- Ensure functions can take class objects as arguments and return them as results
Inline class methods (necessary for an easy fix for mpi4py, see Broken mpi4py support #251 )

Things to add last:

Any improvements to classes that you may suggest

0 replies

sboof911 · 2023-07-12T10:11:52Z

sboof911
Jul 12, 2023
Collaborator

I was trying to find the best way to implement the classes in c and I found this method is the more readable and close to the concept of classes.
For the implementation of the struct that contains references to the __init__(Constructer) and __del__(Destructor) functions:

#ifndef TESTMOD_H
#define TESTMOD_H

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct A A;

struct A
{
    void    (*Constructor)(A*, double);
    void    (*Destructor)(A*);
    void    (*function)(A*, double);
    double   a;
};

void     Class_A(A* self, double a);
void    function_A(A* self, double x);
void    function2_A(A* self, double x);
void    function3_A(A* self, double x);

#endif

And for the implementation of the function we should declare them by this syntax.

void    Destructor_A(A* self)
{
    free(self);
    printf("Destructor Called\n");
}

void    Constructor_A(A* self, double a)
{
    self->a = a;
    printf("Contructor Called\n");
}

void   function_A(A* self, double x)
{
        self->a += x;
}

void   function2_A(A* self, double x)
{
        for(long long int i = 0; i < 10000000000; i++)
             function_A(self, x);
}

void   function3_A(A* self, double x)
{
        for(long long int i = 0; i < 10000000000; i++)
             self->function(self, x);
}

void     Class_A(A* self, double a)
{
    self->Constructor = Constructor_A;
    self->function = function_A;
    self->Destructor = Destructor_A;
    self->Constructor(self, a); // Call the constructor
}

The declaration of the functions are in a way we will avoid name collision eg: FunctionName_ClassName.
Here is a main that test that compare the compilation time between a function pointer call and a function call.

void show_time(char *str, struct timespec *tv1, struct timespec *tv2)
{
  printf("%s: %ld seconds\n", str, tv2->tv_sec-tv1->tv_sec);
//   printf("%s: %ld nano seconds\n", str, tv2->tv_nsec-tv1->tv_nsec);
}

int main(void)
{
    A* p = malloc(sizeof(A));
    Class_A(p, 0.0);
    {
        struct timespec  tv1, tv2;
        timespec_get(&tv1, TIME_UTC);
        for(long long int i = 0; i < 10000000000; i++)
            p->function(p, 1);
        timespec_get(&tv2, TIME_UTC);

        show_time("function pointer call timing", &tv1, &tv2);
    }
    {
        struct timespec  tv1, tv2;
        timespec_get(&tv1, TIME_UTC);
        for(long long int i = 0; i < 10000000000; i++)
            function_A(p, 1);
        timespec_get(&tv2, TIME_UTC);

        show_time("function call timing", &tv1, &tv2);
    }
    {
        struct timespec  tv1, tv2;
        timespec_get(&tv1, TIME_UTC);
        function3_A(p, 1);
        timespec_get(&tv2, TIME_UTC);

        show_time("class function pointer call timing", &tv1, &tv2);
    }
    {
        struct timespec  tv1, tv2;
        timespec_get(&tv1, TIME_UTC);
        function2_A(p, 1);
        timespec_get(&tv2, TIME_UTC);

        show_time("class function call timing", &tv1, &tv2);
    }
    p->Destructur(p);
}

And here is his output that shows difference between the function pointer call and the function call using gcc version 11.03 with the -O3 flag.

Contructor Called
function pointer call timing: 32 seconds
function call timing: 36 seconds
class function pointer call timing: 35 seconds
class function call timing: 11 seconds
Destructor Called

11 replies

sboof911 Jul 12, 2023
Collaborator

we don't really need both of them, but it gives a little of readability in the code.

EmilyBourne Jul 12, 2023
Collaborator

On my computer I get the following results with this code and -O3:

Contructor Called
function pointer call timing: 28 seconds
function call timing: 20 seconds
class function pointer call timing: 27 seconds
class function call timing: 5 seconds
Destructor Called
-----------------------------------
Contructor Called
function pointer call timing: 25 seconds
function call timing: 20 seconds
class function pointer call timing: 26 seconds
class function call timing: 6 seconds
Destructor Called
-----------------------------------
Contructor Called
function pointer call timing: 26 seconds
function call timing: 22 seconds
class function pointer call timing: 25 seconds
class function call timing: 6 seconds
Destructor Called

I am also using gcc 11.3

EmilyBourne Jul 12, 2023
Collaborator

Results with -O2 are equivalent

EmilyBourne Jul 12, 2023
Collaborator

Results with the flags -flto -O3:

Contructor Called
function pointer call timing: 5 seconds
function call timing: 21 seconds
class function pointer call timing: 29 seconds
class function call timing: 6 seconds
Destructor Called

EmilyBourne Jul 12, 2023
Collaborator

Results with nvc v23.1, flags -O3:

Contructor Called
function pointer call timing: 23 seconds
function call timing: 24 seconds
class function pointer call timing: 26 seconds
class function call timing: 6 seconds
Destructor Called

sboof911 · 2023-07-12T11:08:35Z

sboof911
Jul 12, 2023
Collaborator

What flags did you use?

I used the -O3 flag

0 replies

EmilyBourne · 2023-07-12T15:15:19Z

EmilyBourne
Jul 12, 2023
Collaborator

The main question remaining to be resolved here is whether we should use functions alongside a structure or function pointers inside the structure. My preference would be for functions alongside a structure. I have listed the advantages of each approach below. Please feel free to modify this post to add additional advantages.

functions alongside a structure

Significantly faster (2-5x) when called inside the file where they are defined (or using -flto)
Slightly faster generally
Looks like class implementations that I have seen in codes in C or Fortran < 2003
- This seems to be a common opinion, e.g. from stack overflow:
  
  C has namespaces. The syntax is namespace_name
  
  https://stackoverflow.com/a/1403922/5957195
No more verbose than the alternative
No need to use the class instance twice in the call

function pointers

Looks closer to a class in Python or C++
Function name is not mangled

Vote

🎉 - functions alongside a structure
🚀 - function pointers

cc: @sboof911 @bauom @yguclu @saidctb

1 reply

EmilyBourne Jul 12, 2023
Collaborator

Personally I see more advantages for functions alongside a structure, and I don't find this syntax to be particularly difficult to read so I don't see a strong disadvantage

handle python classes #1119

Uh oh!

MostafaMamouni May 30, 2022 Collaborator

Replies: 5 comments · 12 replies

Uh oh!

EmilyBourne Jun 2, 2022 Collaborator

Uh oh!

Uh oh!

EmilyBourne Jul 2, 2022 Collaborator

Uh oh!

Uh oh!

sboof911 Jul 12, 2023 Collaborator

Uh oh!

Uh oh!

sboof911 Jul 12, 2023 Collaborator

Uh oh!

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

Uh oh!

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

Uh oh!

sboof911 Jul 12, 2023 Collaborator

Uh oh!

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

functions alongside a structure

function pointers

Vote

Uh oh!

EmilyBourne Jul 12, 2023 Collaborator

MostafaMamouni
May 30, 2022
Collaborator

Replies: 5 comments 12 replies

EmilyBourne
Jun 2, 2022
Collaborator

EmilyBourne
Jul 2, 2022
Collaborator

sboof911
Jul 12, 2023
Collaborator

sboof911 Jul 12, 2023
Collaborator

EmilyBourne Jul 12, 2023
Collaborator

EmilyBourne Jul 12, 2023
Collaborator

EmilyBourne Jul 12, 2023
Collaborator

EmilyBourne Jul 12, 2023
Collaborator

sboof911
Jul 12, 2023
Collaborator

EmilyBourne
Jul 12, 2023
Collaborator

EmilyBourne Jul 12, 2023
Collaborator