[FEA]: private constructor prevents derived classes of cythonized Stream, Event

[carterbox]

Is this a duplicate?

• I confirmed there appear to be no duplicate issues for this request and that I agree to the Code of Conduct

Area

cuda.core

Is your feature request related to a problem? Please describe.

In nvmath-python we have test the correctness of our code by checking how many times we have called Event.sync(). We used to do this by monkeypatching the Event class, so that it would update a global variable whenever called. This is no longer possible because Event is an immutable cython class in cuda-core 0.3.1, so it is unpatchable.

The alternative approach for us would be to create a derived class LoggedSyncEvent which overwrites the sync() method with our modified method. However, this is not possible because Event subverts the conventional constructor method __init__() and instead implements _init(). The problem with this custom constructor is that it will always return an Event even in derived classes (as opposed to __init__() which cython knows how to handle properly for class inheritance).

Describe the solution you'd like

Use the standard __init__() method for class constructors instead of using engineering controls to preventing users from calling the constructor directly by hiding the constructor in _init(). Instead just use procedural controls by just mentioning in the documentation that calling __init__() is deprecated/unsupported/unstable.

For example:

diff --git a/cuda_core/cuda/core/experimental/_event.pyx b/cuda_core/cuda/core/experimental/_event.pyx
index 94496985..76bb7b96 100644
--- a/cuda_core/cuda/core/experimental/_event.pyx
+++ b/cuda_core/cuda/core/experimental/_event.pyx
@@ -84,12 +84,7 @@ cdef class Event:
         int _device_id
         object _ctx_handle

-    def __init__(self, *args, **kwargs):
-        raise RuntimeError("Event objects cannot be instantiated directly. Please use Stream APIs (record).")
-
-    @classmethod
-    def _init(cls, device_id: int, ctx_handle: Context, options=None):
-        cdef Event self = Event.__new__(Event)
+    def __init__(self, device_id: int, ctx_handle: Context, options=None):
         cdef EventOptions opts = check_or_create_options(EventOptions, options, "Event options")
         flags = 0x0
         self._timing_disabled = False
@@ -106,7 +101,6 @@ cdef class Event:
         raise_if_driver_error(err)
         self._device_id = device_id
         self._ctx_handle = ctx_handle
-        return self

     cpdef close(self):
         """Destroy the event."""

Describe alternatives you've considered

Playing with cython syntax to try and get _init() to return a derived class instead of always Event. I tried this, but some parameters in the constructor are cdef attributes, so they are not accessible by instances of cls.

Additional context

No response

[shwina]

The alternative approach for us would be to create a derived class LoggedSyncEvent which overwrites the sync() method with our modified method.

I will let another maintainer answer about modifying construction to allow subclassing - I'm not sure if there are any performance concerns.

That being said, would it work to use composition instead of inheritance? Something like:

counter = 0

class EventWrapper:
    def __init__(self, e):
        self._e = e

    def __getattr__(self, attr):
        return getattr(self._e, attr)

    def sync(self):
        global counter
        self._e.sync()
        counter += 1

e = EventWrapper(Device().create_event())
e.sync()
e.sync()
print(counter)  # prints 2

This way you don't have to rely on Event or other types' subclassability.

[shwina]

As another note, the private constructor can still be kept private while allowing this use-case. The required fix is a one-liner:

     @classmethod
     def _init(cls, device_id: int, ctx_handle: Context, options=None):
-        cdef Event self = Event.__new__(Event)
+        cdef cls self = Event.__new__(cls)
         cdef EventOptions opts = check_or_create_options(EventOptions, options, "Event options")
         flags = 0x0
         self._timing_disabled = False

I think this is worth doing for correctness anyway, so I opened #752. Could you please verify it works for you? If you aren't set up with a development environment for cuda-python, I can test on my end if you can point me to the relevant part of the nvmath source.

[carterbox]

Composition doesn't work because you can't pass a composed class to Stream.wait() and have the Stream behave in the expected way. This is because Stream.wait() uses is_instance(Event) which requires inheritance.

I believe the proposed fix to the private constructor does work because now the private constructor will return the correct class in an inheritance situation.

[carterbox]

@leofang, I would like to reopen this issue. Since v0.6.0, it is again no longer possible to inherit from Event, Stream because the private constructor is not visible to python.