replace dparray with descriptor step1 (#523)

* replace dparray with descriptor step1

* get_descriptor() function added

Co-authored-by: Samir Nasibli <[email protected]>

Author: shssf

dpnp/dpnp_algo/dpnp_algo_mathematical.pyx

@@ -257,7 +257,7 @@ cpdef dparray dpnp_minimum(object x1_obj, object x2_obj, object dtype=None, dpar
     return call_fptr_2in_1out(DPNP_FN_MINIMUM, x1_obj, x2_obj, dtype=dtype, out=out, where=where)
 
 
-cpdef tuple dpnp_modf(dparray x1):
+cpdef tuple dpnp_modf(dpnp_descriptor x1):
     """ Convert string type names (dparray.dtype) to C enum DPNPFuncType """
     cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
 

dpnp/dpnp_iface.py

@@ -56,6 +56,7 @@
     "asnumpy",
     "dpnp_queue_initialize",
     "dpnp_queue_is_cpu",
+    "get_dpnp_descriptor",
     "get_include",
     "matmul"
 ]
@@ -134,6 +135,32 @@ def asnumpy(input, order='C'):
     return numpy.asarray(input, order=order)
 
 
+def get_dpnp_descriptor(ext_obj):
+    """
+    Return True:
+      never
+    Return DPNP internal data discriptor object if:
+      1. We can proceed with input data object with DPNP
+      2. We want to handle input data object
+    Return False if:
+      1. We do not want to work with input data object
+      2. We can not handle with input data object
+    """
+
+    # TODO need to allow "import dpnp" with no build procedure
+    # if no_modules_load_doc_build();
+    #    return False
+
+    if use_origin_backend():
+        return False
+
+    dpnp_desc = dpnp_descriptor(ext_obj)
+    if dpnp_desc.is_valid:
+        return dpnp_desc
+
+    return False
+
+
 def get_include():
     """
     Return the directory that contains the DPNP C++ backend \\*.h header files.

dpnp/dpnp_iface_mathematical.py

@@ -1040,11 +1040,10 @@ def modf(x, **kwargs):
 
 
     """
-    if not use_origin_backend(x) and not kwargs:
-        if not isinstance(x, dparray):
-            pass
-        else:
-            return dpnp_modf(x)
+
+    dpnp_desc = dpnp.get_dpnp_descriptor(x)
+    if dpnp_desc and not kwargs:
+        return dpnp_modf(dpnp_desc)
 
     return call_origin(numpy.modf, x, **kwargs)
 

dpnp/dpnp_utils/dpnp_algo_utils.pxd

@@ -130,6 +130,17 @@ cpdef nd2dp_array(arr)
 Convert ndarray to dparray
 """
 
+cdef class dpnp_descriptor:
+    """array DPNP descriptor"""
+
+    cdef public:  # TODO remove "public" as python accessible attribute
+        dict descriptor
+        Py_ssize_t dpnp_descriptor_data_size
+        cpp_bool dpnp_descriptor_is_scalar
+
+    cdef void * get_data(self)
+
+
 cdef dparray_shape_type get_common_shape(dparray_shape_type input1_shape, dparray_shape_type input2_shape)
 """
 Calculate common shape from input shapes

dpnp/dpnp_utils/dpnp_algo_utils.pyx

@@ -54,6 +54,7 @@ __all__ = [
     "checker_throw_type_error",
     "checker_throw_value_error",
     "dp2nd_array",
+    "dpnp_descriptor",
     "get_axis_indeces",
     "get_axis_offsets",
     "_get_linear_index",
@@ -71,6 +72,8 @@ def call_origin(function, *args, **kwargs):
     Call fallback function for unsupported cases
     """
 
+    # print(f"DPNP call_origin(): Fallback called")
+
     kwargs_out = kwargs.get("out", None)
     if (kwargs_out is not None):
         kwargs["out"] = dpnp.asnumpy(kwargs_out) if isinstance(kwargs_out, dparray) else kwargs_out
@@ -431,3 +434,77 @@ cpdef cpp_bool use_origin_backend(input1=None, size_t compute_size=0):
         return True
 
     return False
+
+
+cdef class dpnp_descriptor:
+    def __init__(self, obj):
+        """ Initialze variables """
+        self.descriptor = None
+        self.dpnp_descriptor_data_size = 0
+        self.dpnp_descriptor_is_scalar = True
+
+        """ Accure main data storage """
+        self.descriptor = getattr(obj, "__array_interface__", None)
+        if self.descriptor is None:
+            return
+
+        if self.descriptor["version"] != 3:
+            return
+
+        """ array size calculation """
+        cdef Py_ssize_t shape_it = 0
+        self.dpnp_descriptor_data_size = 1
+        for shape_it in self.shape:
+            # TODO need to use common procedure from utils to calculate array size by shape
+            if shape_it < 0:
+                raise ValueError(f"{ERROR_PREFIX} dpnp_descriptor::__init__() invalid value {shape_it} in 'shape'")
+            self.dpnp_descriptor_data_size *= shape_it
+
+        """ set scalar propery """
+        self.dpnp_descriptor_is_scalar = False
+
+    @property
+    def is_valid(self):
+        if self.descriptor is None:
+            return False
+        return True
+
+    @property
+    def shape(self):
+        if self.is_valid:
+            return self.descriptor["shape"]
+        return None
+
+    @property
+    def size(self):
+        if self.is_valid:
+            return self.dpnp_descriptor_data_size
+        return 0
+
+    @property
+    def dtype(self):
+        if self.is_valid:
+            type_str = self.descriptor["typestr"]
+            return dpnp.dtype(type_str)
+        return None
+
+    @property
+    def is_scalar(self):
+        return self.dpnp_descriptor_is_scalar
+
+    @property
+    def data(self):
+        if self.is_valid:
+            data_tuple = self.descriptor["data"]
+            return data_tuple[0]
+        return None
+
+    cdef void * get_data(self):
+        cdef long val = self.data
+        return < void * > val
+
+    def __bool__(self):
+        return self.is_valid
+
+    def __str__(self):
+        return str(self.descriptor)