zuspec-arl-eval 0.0.8.13275646385rc0__cp310-cp310-manylinux_2_28_x86_64.whl

zsp_arl_eval/__build_num__.py

@@ -0,0 +1 @@
+BUILD_NUM=13275646385

zsp_arl_eval/__init__.py

@@ -0,0 +1,20 @@
+import os
+
+def get_deps():
+    return []
+
+def get_libs():
+    return ["zsp-arl-eval"]
+
+def get_libdirs():
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    return [pkg_dir]
+
+def get_incdirs():
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    if os.path.isdir(os.path.join(pkg_dir, "include")):
+        return [os.path.join(pkg_dir, "include")]
+    else:
+        root_dir = os.path.abspath(os.path.join(pkg_dir, "../.."))
+        return [os.path.join(root_dir, "src", "include")]
+

zsp_arl_eval/__version__.py

@@ -0,0 +1,3 @@
+BASE="0.0.8"
+SUFFIX=".13275646385rc0"
+VERSION="%s%s" % (BASE, SUFFIX)

zsp_arl_eval/core.pxd

@@ -0,0 +1,133 @@
+#****************************************************************************
+#* arl_dm_eval core.pxd
+#*
+#****************************************************************************
+import ctypes
+cimport debug_mgr.core as dm_core
+cimport vsc_solvers.core as vsc_solvers
+cimport zsp_arl_dm.core as arl_dm
+from zsp_arl_eval cimport decl
+
+from libc.stdint cimport int32_t
+from libcpp cimport bool
+from libcpp.string cimport string as cpp_string
+cimport vsc_dm.core as vsc
+cimport vsc_dm.decl as vsc_decl
+cimport pyapi_compat_if.core as pyapi
+cimport pyapi_compat_if.decl as pyapi_decl
+
+cdef class Factory(object):
+    cdef decl.IFactory      *_hndl
+    cdef pyapi.PyEval       _pyeval
+
+    cdef init(self, dm_core.Factory)
+
+    cpdef EvalContext mkEvalContextFullElab(
+        self,
+        vsc_solvers.Factory           solvers_f,
+        arl_dm.Context                ctxt,
+        vsc_solvers.RandState         randstate,
+        arl_dm.DataTypeComponent      root_comp,
+        arl_dm.DataTypeAction         root_action,
+        EvalBackend                   backend)
+
+    cpdef ModelEvaluator mkModelEvaluator(
+        self,
+        kind,
+        vsc_solvers.Factory solvers_f,
+        arl_dm.Context      ctxt)
+
+cdef class EvalBackend(object):
+    cdef decl.EvalBackendClosure    *_hndl
+
+cdef class Eval(object):
+    cdef decl.IEval                 *_hndl
+    cdef bool                       _owned
+
+    cpdef bool eval(self)
+
+    cpdef bool hasFlags(self, flags)
+
+    cpdef vsc.ValRef getResult(self)
+
+    cpdef void setResult(self, vsc.ValRef r, flags=*)
+
+    @staticmethod
+    cdef Eval mk(decl.IEval *hndl, bool owned=*)
+
+cdef class EvalContext(object):
+    cdef decl.IEvalContext          *_hndl
+    cdef bool                       _owned
+
+    cpdef bool eval(self)
+
+    cpdef bool hasFlags(self, flags)
+
+    cpdef vsc.ValRef getResult(self)
+
+    cpdef getSolveFunctions(self)
+
+    cpdef getTargetFunctions(self)
+
+    cpdef bool addPyModule(self, str name, object mod)
+
+    cpdef vsc.ValRefInt mkValRefInt(self, int value, bool is_signed, int width)
+
+    cpdef vsc.ValRefInt getAddrHandleValue(self, vsc.ValRef val)
+
+    # cpdef EvalResult mkEvalResultVal(self, vsc.ModelVal v)
+
+    # cpdef EvalResult mkEvalResultValS(self, int val, int bits=*)
+
+    # cpdef EvalResult mkEvalResultValU(self, int val, int bits=*)
+
+    # cpdef EvalResult mkEvalResultKind(self, kind)
+
+    # cpdef EvalResult mkEvalResultRef(self, vsc.ModelField ref)
+
+    cdef decl.IEvalContext *asContext(self)
+
+    @staticmethod
+    cdef EvalContext mk(decl.IEvalContext *hndl, bool owned=*)
+
+cdef class EvalThread(Eval):
+
+    cpdef void setThreadId(self, obj)
+    
+    cpdef object getThreadId(self)
+
+    cpdef vsc.ValRefInt mkValRefInt(self, int value, bool is_signed, int width)
+
+    cpdef vsc.ValRefInt getAddrHandleValue(self, vsc.ValRef val)
+
+    # cpdef EvalResult mkEvalResultVal(self, vsc.ModelVal v)
+
+    # cpdef EvalResult mkEvalResultValS(self, int val, int bits=*)
+
+    # cpdef EvalResult mkEvalResultValU(self, int val, int bits=*)
+
+    # cpdef EvalResult mkEvalResultKind(self, kind)
+
+    # cpdef EvalResult mkEvalResultRef(self, vsc.ModelField ref)
+
+    cdef decl.IEvalThread *asThread(self)
+
+    @staticmethod
+    cdef EvalThread mk(decl.IEvalThread *hndl, bool owned=*)
+
+cdef class ModelEvaluator(object):
+    cdef decl.IModelEvaluator       *_hndl
+    cdef bool                       _owned
+
+    cpdef arl_dm.ModelEvalIterator eval(
+        self,
+        vsc_solvers.RandState           randstate,
+        arl_dm.ModelFieldComponent      root_comp,
+        arl_dm.DataTypeAction           root_action)
+
+    @staticmethod
+    cdef ModelEvaluator mk(decl.IModelEvaluator *hndl, bool owned=*)
+
+    pass
+    
+    

zsp_arl_eval/decl.pxd

@@ -0,0 +1,140 @@
+#****************************************************************************
+#* arl_dm_eval decl.pxd
+#*
+#****************************************************************************
+cimport vsc_dm.decl as vsc
+cimport vsc_solvers.decl as vsc_solvers
+cimport zsp_arl_dm.decl as arl_dm
+cimport debug_mgr.decl as dm
+cimport pyapi_compat_if.decl as pyapi
+
+from libcpp.string cimport string as cpp_string
+from libcpp.vector cimport vector as cpp_vector
+from libcpp.memory cimport unique_ptr
+from libcpp cimport bool
+from libc.stdint cimport int32_t, int64_t, uint64_t
+cimport cpython.ref as cpy_ref
+
+ctypedef EvalThreadData *EvalThreadDataP
+ctypedef IFactory *IFactoryP
+ctypedef IEvalContext *IEvalContextP
+ctypedef IEvalThread *IEvalThreadP
+ctypedef IEvalThreadId *IEvalThreadIdP
+
+cdef extern from "zsp/arl/eval/IFactory.h" namespace "zsp::arl::eval":
+    cdef cppclass IFactory:
+        void init(dm.IDebugMgr *)
+
+        IModelEvaluator *mkModelEvaluator(
+            ModelEvaluatorKind      kind,
+            vsc_solvers.IFactory    *solvers_f,
+            arl_dm.IContext         *ctxt)
+
+        IEvalContext *mkEvalContextFullElab(
+            vsc_solvers.IFactory            *solvers_f,
+            arl_dm.IContext                 *ctxt,
+            const vsc_solvers.IRandState    *randstate,
+            pyapi.IPyEval                   *pyeval,
+            arl_dm.IDataTypeComponent       *root_comp,
+            arl_dm.IDataTypeAction          *root_action,
+            IEvalBackend                    *backend)
+
+# cdef extern from "zsp/arl/eval/IEvalResult.h" namespace "zsp::arl::eval":
+#     cdef enum EvalResultKind:
+#         ResultKind_Void "zsp::arl::eval::EvalResultKind::Void"
+#         ResultKind_Val "zsp::arl::eval::EvalResultKind::Val"
+#         ResultKind_Ref "zsp::arl::eval::EvalResultKind::Ref"
+#         ResultKind_Break "zsp::arl::eval::EvalResultKind::Break"
+#         ResultKind_Continue "zsp::arl::eval::EvalResultKind::Continue"
+
+#     cdef cppclass IEvalResult(vsc.IModelVal):
+#         pass
+
+cdef extern from "zsp/arl/eval/IEval.h" namespace "zsp::arl::eval":
+    cdef enum EvalFlags "zsp::arl::eval::EvalFlags":
+        EvalFlags_NoFlags "zsp::arl::eval::EvalFlags::NoFlags"
+        EvalFlags_Complete "zsp::arl::eval::EvalFlags::Complete"
+        EvalFlags_Error "zsp::arl::eval::EvalFlags::Error"
+        EvalFlags_Break "zsp::arl::eval::EvalFlags::Break"
+        EvalFlags_Continue "zsp::arl::eval::EvalFlags::Continue"
+        EvalFlags_Return "zsp::arl::eval::EvalFlags::Return"
+
+    cdef cppclass IEval:
+        bool eval()
+        bool hasFlags(EvalFlags flags) const
+        vsc.ValRef getResult()
+        void setResult(const vsc.ValRef &, EvalFlags flags)
+
+
+cdef extern from "zsp/arl/eval/IEvalBackend.h" namespace "zsp::arl::eval":
+    cdef cppclass IEvalBackend:
+        void enterThreads(const cpp_vector[IEvalThreadP] &)
+
+        void enterThread(IEvalThread *)
+
+        void leaveThread(IEvalThread *)
+
+        void leaveThreads(const cpp_vector[IEvalThreadP] &)
+
+        void callFuncReq(
+            IEvalThread                     *thread,
+            arl_dm.IDataTypeFunction        *func_t,
+            const cpp_vector[vsc.ValRef]    &params)
+
+        void emitMessage(const cpp_string &msg)
+
+cdef extern from "zsp/arl/eval/IEvalContext.h" namespace "zsp::arl::eval":
+    cdef cppclass IEvalContext(IEval):
+        IEvalBackend *getBackend() const
+        void setBackend(IEvalBackend *b)
+        const cpp_vector[arl_dm.IDataTypeFunctionP] &getSolveFunctions() const
+        const cpp_vector[arl_dm.IDataTypeFunctionP] &getTargetFunctions() const
+        bool addPyModule(const cpp_string &, pyapi.PyEvalObj *mod)
+
+        vsc.ValRefInt mkValRefInt(int64_t value, bool is_signed, int32_t width)
+        vsc.ValRefInt getAddrHandleValue(const vsc.ValRef &)
+        # IEvalResult *mkEvalResultVal(vsc.IModelVal *val)
+        # IEvalResult *mkEvalResultValS(int64_t val, int32_t bits)
+        # IEvalResult *mkEvalResultValU(uint64_t val, int32_t bits)
+        # IEvalResult *mkEvalResultKind(EvalResultKind kind)
+        # IEvalResult *mkEvalResultRef(vsc.IModelField *ref)
+
+#        const cpp_vector[arl_dm.IModelFieldExecutor] &getFunctions() const
+
+cdef extern from "EvalBackendClosure.h" namespace "zsp::arl::eval":
+    cdef cppclass EvalBackendClosure(IEvalBackend):
+        EvalBackendClosure(cpy_ref.PyObject *)
+
+cdef extern from "zsp/arl/eval/IEvalThreadId.h" namespace "zsp::arl::eval":
+    cdef cppclass IEvalThreadId:
+        pass
+
+cdef extern from "zsp/arl/eval/IEvalThread.h" namespace "zsp::arl::eval":
+    cdef cppclass IEvalThread(IEval):
+        void setThreadId(IEvalThreadId *)
+        IEvalThreadId *getThreadId()
+        vsc.ValRefInt mkValRefInt(int64_t value, bool is_signed, int32_t width)
+        vsc.ValRefInt getAddrHandleValue(const vsc.ValRef &)
+        # IEvalResult *mkEvalResultVal(vsc.IModelVal *val)
+        # IEvalResult *mkEvalResultValS(int64_t val, int32_t bits)
+        # IEvalResult *mkEvalResultValU(uint64_t val, int32_t bits)
+        # IEvalResult *mkEvalResultKind(EvalResultKind kind)
+        # IEvalResult *mkEvalResultRef(vsc.IModelField *ref)
+
+cdef extern from "EvalThreadData.h" namespace "zsp::arl::eval":
+    cdef cppclass EvalThreadData(IEvalThreadId):
+        EvalThreadData(cpy_ref.PyObject *)
+        object getData() const
+
+cdef extern from "zsp/arl/eval/IModelEvaluator.h" namespace "zsp::arl::eval":
+    cdef enum ModelEvaluatorKind "zsp::arl::eval::ModelEvaluatorKind" :
+        ModelEvaluatorKind_FullElab "zsp::arl::eval::ModelEvaluatorKind::FullElab"
+        ModelEvaluatorKind_IncrElab "zsp::arl::eval::ModelEvaluatorKind::IncrElab"
+
+    cdef cppclass IModelEvaluator:
+        arl_dm.IModelEvalIterator *eval(
+            const vsc_solvers.IRandState    *randstate,
+            arl_dm.IModelFieldComponent     *root_comp,
+            arl_dm.IDataTypeAction          *root_action)
+
+

zsp_arl_eval/pkginfo.py

@@ -0,0 +1,24 @@
+import os
+import ivpm
+
+class PkgInfo(ivpm.PkgInfo):
+
+    def __init__(self):
+        pkgdir = os.path.dirname(os.path.abspath(__file__))
+        projdir = os.path.dirname(os.path.dirname(pkgdir))
+        super().__init__("zuspec-arl-eval", os.path.dirname(pkgdir))
+
+        if os.path.isdir(os.path.join(projdir, "src")):
+            self._incdirs = [
+                os.path.join(projdir, "src", "include"),
+                os.path.join(projdir, "python")]
+            self._libdirs = [
+                os.path.join(projdir, "build", "lib"),
+                os.path.join(projdir, "build", "lib64")]
+        else:
+            self._incdirs = [os.path.join(pkgdir, "share", "include")]
+            self._libdirs = [os.path.join(pkgdir)]
+
+        self._deps = ["zuspec-arl-dm", "vsc-solvers"]
+
+        self._libs = ["zsp-arl-eval"]

zsp_arl_eval/share/include/EvalBackendClosure.h

@@ -0,0 +1,76 @@
+/**
+ * EvalBackendClosure.h
+ *
+ * Copyright 2023 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include <Python.h>
+#include "zsp/arl/eval/impl/EvalBackendBase.h"
+#include "zsp/arl/eval/IEvalBackend.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class EvalBackendClosure : public virtual EvalBackendBase {
+public:
+    EvalBackendClosure(PyObject *peer);
+
+    virtual ~EvalBackendClosure();
+
+    virtual void enterThreads(
+        const std::vector<IEvalThread *>    &threads) override;
+    
+    virtual void enterThread(IEvalThread *thread) override;
+
+    virtual void leaveThread(IEvalThread *thread) override;
+
+    virtual void leaveThreads(
+        const std::vector<IEvalThread *>    &threads) override;
+
+    virtual void enterAction(
+        IEvalThread                         *thread,
+        dm::IDataTypeAction                 *action_t,
+        const vsc::dm::ValRef               &action_v) override;
+
+    virtual void leaveAction(
+        IEvalThread                         *thread,
+        dm::IDataTypeAction                 *action_t,
+        const vsc::dm::ValRef               &action_v) override;
+
+    virtual void callFuncReq(
+            IEvalThread                         *thread,
+            dm::IDataTypeFunction               *func_t,
+            const std::vector<vsc::dm::ValRef>  &params
+    ) override;
+
+    virtual void emitMessage(
+            const std::string                   &msg
+    ) override;
+
+private:
+    PyObject                            *m_peer;
+};
+
+}
+}
+}
+
+

zsp_arl_eval/share/include/EvalThreadData.h

@@ -0,0 +1,48 @@
+/**
+ * EvalThreadData.h
+ *
+ * Copyright 2023 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include <Python.h>
+#include "zsp/arl/eval/IEvalThreadId.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+
+
+class EvalThreadData : public virtual IEvalThreadId {
+public:
+    EvalThreadData(PyObject *obj);
+
+    virtual ~EvalThreadData();
+
+    PyObject *getData() const { return m_obj; }
+
+private:
+    PyObject                *m_obj;
+
+};
+
+}
+}
+}
+
+

zsp_arl_eval/share/include/zsp/arl/eval/FactoryExt.h

@@ -0,0 +1,27 @@
+/**
+ * FactoryExt.h
+ *
+ * Copyright 2022 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include "zsp/arl/eval/IFactory.h"
+
+extern "C" zsp::arl::eval::IFactory *zsp_arl_eval_getFactory();
+
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IBuiltinFuncInfo.h

@@ -0,0 +1,77 @@
+/**
+ * IBuiltinFuncInfo.h
+ *
+ * Copyright 2023 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include <functional>
+#include <vector>
+#include "vsc/dm/impl/UP.h"
+#include "vsc/dm/impl/ValRef.h"
+#include "zsp/arl/eval/IEvalThread.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+enum class BuiltinFuncFlags {
+    NoFlags         = 0,
+    RegFunc         = (1 << 0),
+    RegFuncStruct   = (1 << 1),
+    RegFuncWrite    = (1 << 2)
+};
+
+static inline BuiltinFuncFlags operator | (const BuiltinFuncFlags lhs, const BuiltinFuncFlags rhs) {
+        return static_cast<BuiltinFuncFlags>(
+                        static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
+}
+
+static inline BuiltinFuncFlags operator & (const BuiltinFuncFlags lhs, const BuiltinFuncFlags rhs) {
+        return static_cast<BuiltinFuncFlags>(
+                        static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
+}
+
+static inline BuiltinFuncFlags operator ~ (const BuiltinFuncFlags lhs) {
+        return static_cast<BuiltinFuncFlags>(~static_cast<uint32_t>(lhs));
+}
+
+class IBuiltinFuncInfo;
+using IBuiltinFuncInfoUP=vsc::dm::UP<IBuiltinFuncInfo>;
+class IBuiltinFuncInfo {
+public:
+
+    using FuncT=std::function<void(
+        IEvalThread *,
+        dm::IDataTypeFunction *,
+        const std::vector<vsc::dm::ValRef> &)>;
+
+    virtual ~IBuiltinFuncInfo() { }
+
+    virtual const FuncT &getImpl() const = 0;
+
+    virtual BuiltinFuncFlags getFlags() const = 0;
+
+    virtual bool hasFlags(BuiltinFuncFlags flags) const = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+

zsp_arl_eval/share/include/zsp/arl/eval/IComponentTreeData.h

@@ -0,0 +1,49 @@
+/**
+ * IComponentTreeData.h
+ *
+ * Copyright 2023 Matthew Ballance and Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may 
+ * not use this file except in compliance with the License.  
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software 
+ * distributed under the License is distributed on an "AS IS" BASIS, 
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
+ * See the License for the specific language governing permissions and 
+ * limitations under the License.
+ *
+ * Created on:
+ *     Author: 
+ */
+#pragma once
+#include "vsc/dm/impl/UP.h"
+
+namespace zsp {
+namespace arl {
+namespace eval {
+
+class IComponentTreeData;
+using IComponentTreeDataUP=vsc::dm::UP<IComponentTreeData>;
+class IComponentTreeData {
+public:
+    struct TypeMapE {
+        std::vector<int32_t>        parent_id;
+        std::vector<int32_t>        child_id;
+    };
+    using TypeM=std::vector<TypeMapE>;
+public:
+
+    virtual ~IComponentTreeData() { }
+
+    virtual const TypeM &getTypeMap(arl::dm::IDataTypeComponent *t) = 0;
+
+};
+
+} /* namespace eval */
+} /* namespace arl */
+} /* namespace zsp */
+
+