Convert CppIn/Out/Ref/Var-Ports

src/lava/magma/runtime/message_infrastructure/CMakeLists.txt

@@ -9,6 +9,18 @@ set(MULTI_PROC_SRCS
     "message_infrastructure/csrc/posix_actor.cc"
 )
 
+set(ABSTRACT_PORT_SRCS
+    "message_infrastructure/csrc/abstract_port_implementation.cc"
+)
+
+set(PORT_SRCS
+    "message_infrastructure/csrc/ports.cc"
+)
+
+set(TRANSFORMER_SRCS
+    "message_infrastructure/csrc/transformer.cc"
+)
+
 file (GLOB PY_WRAPPER "message_infrastructure/csrc/message_infrastructure_py_wrapper.cc")
 
 find_package(pybind11 CONFIG)

src/lava/magma/runtime/message_infrastructure/message_infrastructure/csrc/abstract_port_implementation.cc

@@ -22,8 +22,4 @@ std::vector<int> AbstractPortImplementation::GetShape() {
   return this->shape_;
 }
 
-std::vector<PortPtr> AbstractPortImplementation::GetPorts() {
-  return this->ports_;
-}
-
-} // namespace message_infrastructure
+}  // namespace message_infrastrature

src/lava/magma/runtime/message_infrastructure/message_infrastructure/csrc/abstract_port_implementation.h

@@ -5,6 +5,9 @@
 #ifndef ABSTRACT_PORT_IMPLEMENTATION_H_
 #define ABSTRACT_PORT_IMPLEMENTATION_H_
 
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+
 #include <vector>
 
 #include "abstract_port.h"
@@ -17,9 +20,9 @@ class AbstractPortImplementation {
   int Start();
   int Join();
   std::vector<int> GetShape();
-  std::vector<PortPtr> GetPorts();
+  virtual std::vector<PortPtr> GetPorts();
 
-  DataType dtype_;
+  pybind11::dtype dtype_;
   std::vector<int> shape_;
   size_t size_;
   ProcessModel process_model_;

src/lava/magma/runtime/message_infrastructure/message_infrastructure/csrc/message_infrastructure_py_wrapper.cc

@@ -11,6 +11,8 @@
 #include "shm.h"
 // #include "shmem_channel.h"
 // #include "shmem_port.h"
+#include "ports.h"
+#include "transformer.h"
 
 namespace message_infrastructure {
 
@@ -60,7 +62,101 @@ PYBIND11_MODULE(MessageInfrastructurePywrapper, m) {
     .def("get_dstport", &ShmemChannel::GetDstPort, return_value_policy::reference);
   m.def("get_shmemchannel", &GetShmemChannel, return_value_policy::reference);
   */
-}
 
+  py::class_<AbstractCppPort> (m, "AbstractPyPort")
+    .def(py::init<>());
+
+  py::class_<AbstractCppIOPort> (m, "AbstractPyIOPort")
+    .def("ports", &AbstractCppIOPort::GetPorts);
+
+  py::class_<CppInPort> (m, "PyInPort")
+    .def("probe", &CppInPort::Probe);
+
+  py::class_<CppInPortVectorDense> (m, "PyInPortVectorDense")
+    .def("recv", &CppInPortVectorDense::Recv)
+    .def("peek", &CppInPortVectorDense::Peek);
+
+  py::class_<CppInPortVectorSparse> (m, "PyInPortVectorSparse")
+    .def("recv", &CppInPortVectorSparse::Recv)
+    .def("peek", &CppInPortVectorSparse::Peek);
+
+  py::class_<CppInPortScalarDense> (m, "PyInPortScalarDense")
+    .def("recv", &CppInPortScalarDense::Recv)
+    .def("peek", &CppInPortScalarDense::Peek);
+
+  py::class_<CppInPortScalarSparse> (m, "PyInPortScalarSparse")
+    .def("recv", &CppInPortScalarSparse::Recv)
+    .def("peek", &CppInPortScalarSparse::Peek);
+
+  py::class_<CppOutPort> (m, "PyOutPort")
+    .def(py::init<>());
+
+  py::class_<CppOutPortVectorDense> (m, "PyOutPortVectorDense")
+    .def("send", &CppOutPortVectorDense::Send);
+
+  py::class_<CppOutPortVectorSparse> (m, "PyOutPortVectorSparse")
+    .def("send", &CppOutPortVectorSparse::Send);
+
+  py::class_<CppOutPortScalarDense> (m, "PyOutPortScalarDense")
+    .def("send", &CppOutPortScalarDense::Send);
+
+  py::class_<CppOutPortScalarSparse> (m, "PyOutPortScalarSparse")
+    .def("send", &CppOutPortScalarSparse::Send);
+
+  py::class_<CppRefPort> (m, "PyRefPort")
+    .def(py::init<>())
+    .def("ports", &CppRefPort::GetPorts);
+
+  py::class_<CppRefPortVectorDense> (m, "PyRefPortVectorDense")
+    .def("read", &CppRefPortVectorDense::Read)
+    .def("write", &CppRefPortVectorDense::Write);
+
+  py::class_<CppRefPortVectorSparse> (m, "PyRefPortVectorSparse")
+    .def("read", &CppRefPortVectorSparse::Read)
+    .def("write", &CppRefPortVectorSparse::Write);
+
+  py::class_<CppRefPortScalarDense> (m, "PyRefPortScalarDense")
+    .def("read", &CppRefPortScalarDense::Read)
+    .def("write", &CppRefPortScalarDense::Write);
+
+  py::class_<CppRefPortScalarSparse> (m, "PyRefPortScalarSparse")
+    .def("read", &CppRefPortScalarSparse::Read)
+    .def("write", &CppRefPortScalarSparse::Write);
+
+  py::class_<CppVarPort> (m, "PyVarPort")
+    .def(py::init<>());
+    // .def("csp_ports", &CppVarPort::GetCspPorts);
+
+  py::class_<CppVarPortVectorDense> (m, "PyVarPortVectorDense")
+    .def("service", &CppVarPortVectorDense::Service);
+
+  py::class_<CppVarPortVectorSparse> (m, "PyVarPortVectorSparse")
+    .def("recv", &CppVarPortVectorSparse::Recv)
+    .def("peek", &CppVarPortVectorSparse::Peek)
+    .def("service", &CppVarPortVectorSparse::Service);
+
+  py::class_<CppVarPortScalarDense> (m, "PyVarPortScalarDense")
+    .def("recv", &CppVarPortScalarDense::Recv)
+    .def("peek", &CppVarPortScalarDense::Peek)
+    .def("service", &CppVarPortScalarDense::Service);
+
+  py::class_<CppVarPortScalarSparse> (m, "PyVarPortScalarSparse")
+    .def("recv", &CppVarPortScalarSparse::Recv)
+    .def("peek", &CppVarPortScalarSparse::Peek)
+    .def("service", &CppVarPortScalarSparse::Service);
+
+
+  /*
+  py::class_<AbstractTransformer> (m, "AbstractTransformer")
+    .def("transform", &AbstractTransformer::Transform);
+
+  py::class_<IdentityTransformer> (m, "IdentityTransformer")
+    .def("transform", &IdentityTransformer::Transform);
+
+  py::class_<VirtualPortTransformer> (m, "VirtualPortTransformer")
+    .def("transform", &VirtualPortTransformer::Transform)
+    .def("_get_transform", &VirtualPortTransformer::_Get_Transform);
+  */
+}
 
-} // namespace message_infrastructure
+}  // namespace message_infrastructure

src/lava/magma/runtime/message_infrastructure/message_infrastructure/csrc/ports.cc

@@ -0,0 +1,41 @@
+// Copyright (C) 2021-22 Intel Corporation
+// SPDX-License-Identifier: BSD-3-Clause
+// See: https://spdx.org/licenses/
+
+#include <ports.h>
+#include <vector>
+
+namespace message_infrastructure {
+
+std::vector<PortPtr> AbstractCppIOPort::GetPorts() {
+  return this->ports_;
+}
+
+bool CppInPort::Probe() {
+  auto lambda = [&](int acc, int port){return acc && port->Probe();};
+  return std::accumulate(ports_.begin(), ports_.end(), true, lambda);
+}
+ //TODO: Implement transform and change ndarray type 
+ndarray CppInPortVectorDense::Recv(){
+  auto lambda = [&](int acc, int port){return acc + port->Transform();}
+}
+
+int CppInPortScalarDense::Recv() {
+}
+
+int CppInPortScalarDense::Peek() {
+}
+
+std::vector<int> CppInPortScalarSparse::Recv(){
+}
+
+std::vector<int> CppInPortScalarSparse::Peek(){
+}
+
+std::vector <ndarray> CppOutPortVectorDense::Send(ndarray data){
+  for (auto port : this->ports_){
+    port->Send(data);
+  }
+}
+
+}  // namespace message_infrastructure