Experimental work

Author: taehyounpark

py/queryosity/__init__.py

@@ -0,0 +1,2 @@
+from .dataflow import LazyFlow
+from .jit import jit

py/queryosity/cppfunc.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <Python.h>
+
+#include <functional>
+
+namespace queryosity {
+
+namespace py {
+
+template <typename Ret, typename... Args>
+std::function<Ret(Args...)> cppfunc(const std::string& module_name, const std::string& fn_name) {
+    Py_Initialize();
+
+    // Import the module where your cfunc is defined
+    PyObject* myModule = PyImport_ImportModule(module_name.c_str());
+    if (!myModule) {
+        PyErr_Print();
+    }
+
+    // Get the function object from the module
+    PyObject* cfuncObj = PyObject_GetAttrString(myModule, fn_name.c_str());
+    if (!cfuncObj) {
+        PyErr_Print();
+    }
+
+    // Get the address attribute
+    PyObject* cfuncAddr = PyObject_GetAttrString(cfuncObj, "address");
+    if (!cfuncAddr) {
+        PyErr_Print();
+    }
+
+    // Convert address to a callable function pointer in C++
+    void* ptr = PyLong_AsVoidPtr(cfuncAddr);
+    if (!ptr) {
+        PyErr_Print();
+    }
+    typedef Ret(*Callable)(Args...);
+    Callable callable = reinterpret_cast<Callable>(ptr);
+
+    Py_Finalize();
+
+    return std::function<Ret(Args...)>(callable);
+  }
+
+}
+
+}

py/queryosity/dataflow.py

@@ -0,0 +1,37 @@
+import os
+import cppyy
+
+# from .lazy import LazyNode
+# from .todo import TodoItem
+
+queryosity_h = os.path.join(os.path.dirname(os.path.abspath(__file__)),'queryosity.h')
+cppyy.include(queryosity_h)
+
+qty = cppyy.gbl.queryosity
+dataflow = qty.dataflow
+dataset = qty.dataset
+multithread = qty.multithread
+column = qty.column
+query = qty.query
+systematic = qty.systematic
+
+class LazyFlow(object):
+  
+  def __init__(self, *, mt=1, nrows=-1, weight=1.0):
+    if mt is True: mt = -1
+    self._df = dataflow(cppyy.gbl.std.move(multithread.enable(mt)), cppyy.gbl.std.move(dataset.weight(weight)))
+
+  def load(self, dataset):
+    return self._df.load(dataset)
+
+  def define(self, *, definition=None, expression=None, constant=None, observables=[]):
+    return None
+
+  def filter(self, column=None, *, expression=None):
+    return None
+
+  def weight(self, column=None, *, expression=None):
+    return None
+
+  def make(self):
+    return None

py/queryosity/jit.py

@@ -0,0 +1,36 @@
+import os
+import cppyy
+import cppyy.numba_ext
+import numba
+from numba import njit
+
+cppfunc_h = os.path.join(os.path.dirname(os.path.abspath(__file__)),'cppfunc.h')
+cppyy.include(cppfunc_h)
+cppfunc = cppyy.gbl.queryosity.py.cppfunc
+
+# Define the custom decorator with its own arguments
+def jit(args=[], ret=''):
+
+    if not len(args):
+      raise ValueError("no argument types specified.")
+
+    if not ret: 
+      raise ValueError("return type not specified.")
+
+    def decorator(func):
+        # Apply njit with parallel=True to the function
+        jitted_func = njit(parallel=True)(func)
+
+        print(jitted_func.__dict__)
+        
+        # Example pre-processing logic using decorator arguments
+        print("Before calling the njitted function")
+
+        fn = cppfunc[ret,*args](func.__module__, func.__name__)
+
+        # Example post-processing logic
+        print("After calling the njitted function")
+        # Modify the result or perform additional actions here
+        
+        return fn
+    return decorator