generating cpp

comsdk/edge.py

@@ -27,12 +27,8 @@ class InOutMapping(object):
 
 class Edge(object):
     __slots__ = [
-        'pred_module',
-        'pred_name',
-        'morph_module',
-        'morph_name',
-        '_predicate', 
-        '_morphism',
+        'pred_f',
+        'morph_f',
         '_io_mapping',
         'preprocess',
         'postprocess',
@@ -42,12 +38,8 @@ class Edge(object):
                  io_mapping=InOutMapping(),
                  order=0
                  ):
-        self.pred_module = predicate.module
-        self.pred_name = predicate.name
-        self._predicate = predicate.func
-        self.morph_module = morphism.module
-        self.morph_name = morphism.name
-        self._morphism = morphism.func
+        self.pred_f = predicate
+        self.morph_f = morphism
         self._io_mapping = io_mapping
         self.preprocess = lambda pd: None
         self.postprocess = lambda pd: None
@@ -55,24 +47,16 @@ class Edge(object):
 
     def predicate(self, data, dynamic_keys_mapping={}):
         proxy_data = self._io_mapping.build_proxy_data(data, dynamic_keys_mapping)
-        return self._predicate(proxy_data)
+        return self.pred_f.func(proxy_data)
 
     def morph(self, data, dynamic_keys_mapping={}):
         # print(self.pred_name, self.morph_name, self.order)
         proxy_data = self._io_mapping.build_proxy_data(data, dynamic_keys_mapping)
         # print(proxy_data)
         self.preprocess(data)
-        self._morphism(proxy_data)
+        self.morph_f.func(proxy_data)
         self.postprocess(data)
     
-    def __str__(self):
-        out = ""
-        if not (self.pred_module =="" or self.pred_name ==""):
-            out += "{}::{}(data);\n".format(self.pred_module, self.pred_name)
-        if not (self.morph_module =="" or self.morph_name ==""):
-            out += "{}::{}(data);\n".format(self.morph_module, self.morph_name)
-        return out
-    
 
 # class DummyEdge(Edge):
     # def __init__(self):

comsdk/graph.py

@@ -4,6 +4,7 @@ from enum import Enum, auto
 from functools import partial
 import importlib as imp
 
+
 import comsdk.aux as aux
 
 ImplicitParallelizationInfo = collections.namedtuple('ImplicitParallelizationInfo', ['array_keys_mapping', 'branches_number', 'branch_i'])
@@ -31,7 +32,9 @@ class Func():
                 raise Exception("Could not load function {} from {} module".format(name, module))
 
     def __str__(self):
-        return "{}.{}()".format(self.module, self.name)
+        if self.module =="" or self.name =="":
+            return ''
+        return "{}_{}".format(self.module, self.name)
 
 class Selector(Func):
     def __init__(self, ntransf, module="", name="", dummy=False):
@@ -98,7 +101,6 @@ class Graph:
             if '__EXCEPTION__' in data:
                 return False
 #            cur_state, implicit_parallelization_info = morph(data)
-            print(cur_state.name, transfer_f) 
             cur_state = transfer_f(data)
 #            print(morph)
             if '__EXCEPTION__' in data:
@@ -115,16 +117,6 @@ class Graph:
         if not '__WORKING_DIR__' in data:
             data['__WORKING_DIR__'] = data['__CURRENT_WORKING_DIR__']
 
-    def generate_cpp(self):
-        cur_state = self.init_state
-        while True:
-            if len(cur_state.transfers)==1:
-                print(cur_state.transfers[0].edge)
-                cur_state = cur_state.transfers[0].output_state
-                if cur_state is None:
-                    break
-            else:
-                break
 
 
 
@@ -141,7 +133,8 @@ class State:
         'array_keys_mapping',
         '_branching_states_history',
         '_proxy_state',
-        'possible_branches'
+        'possible_branches',
+        'comment'
         ]
     def __init__(self, name, 
                  parallelization_policy=None,

comsdk/parser.py

@@ -50,6 +50,8 @@ class GraphFactory():
     def add_state(self, statename):
         if statename not in self.states:
             self.states[statename] = State(statename)
+            if statename in self.entities:
+                self.states[statename].comment = self.entities[statename].comment
     
     def _create_morphism(self, morphname=None):
         if morphname is None:
@@ -110,9 +112,9 @@ class GraphFactory():
                 self.states[s].replace_with_graph(subgr)
         return self.graph
 
+
 class Parser():
     __slots__ = (
-        'entities',
         'fact',
         'issub'
     )
@@ -281,3 +283,30 @@ class Parser():
                 self._topology(ln)
         return self.fact.build(Parser.subgr_count)
 
+    toload = []
+    edgemap = {}
+
+    def _gen_branch(self,cur_state):
+        root = cur_state.name
+        edges = []
+        while cur_state is not None:
+            if len(cur_state.transfers)==0:
+                cur_state = None
+            elif len(cur_state.transfers)==1:
+                edges.append({"pred": str(cur_state.transfers[0].edge.pred_f),
+                              "morph": str(cur_state.transfers[0].edge.morph_f)})
+                if str(cur_state.transfers[0].edge.pred_f) not in self.toload:
+                    self.toload.append(str(cur_state.transfers[0].edge))
+                if str(cur_state.transfers[0].edge.morph_f) not in self.toload:
+                    self.toload.append(str(cur_state.transfers[0].edge))
+                cur_state = cur_state.transfers[0].output_state
+            else:
+                pass
+        self.edgemap[root] = list(filter(lambda x: x["morph"] != '', edges))
+        return 
+
+    def generate_cpp(self):
+        self._gen_branch(self.fact.graph.init_state)
+        print(self.edgemap)
+    
+

cpp/printers.cpp

+#include <iostream>
+#include <anymap.h>
+
+extern "C" {
+    int PrintHello(com::Anymap) {
+        std::cout<<"Hello!" << std::endl;
+        return 0;
+    }
+
+    int PrintBye(com::Anymap) {
+        std::cout<<"Bye!" << std::endl;
+        return 0;
+    }
+
+    int PrintA(com::Anymap) {
+        std::cout<<"A" << std::endl;
+        return 0;
+    }
+
+    int PrintB(com::Anymap) {
+        std::cout<<"B" << std::endl;
+        return 0;
+    }
+
+    bool ReturnTrue(){
+        return true;
+    }
+
+    bool ReturnFalse(){
+        return false;
+    }
+
+    std::list<bool> ThreeTrue(){
+        return false;
+    }
+}
\ No newline at end of file

cpp/run.sh

+g++ -c -fPIC  printers.cpp -o printers.o -I./dev ; g++ printers.o -shared -o libprinters.so; 
+if g++ ./template.cpp -o template.out -I./dev ./dev/core/anymap.cpp  -ldl; then
+./template.out;
+else 
+ echo "Not Compiled!";
+fi;
\ No newline at end of file

cpp/template.cpp

+#include <libtools.h>
+#include <anymap.h>
+#include <thread>
+
+typedef std::function<int(com::Anymap)> IntFunc;
+typedef std::function<bool(com::Anymap)> BoolFunc;
+typedef std::function<std::list<bool>(com::Anymap)> BoolListFunc;  
+
+IntFunc LoadEntry(std::string lib, std::string func) {
+    DllHandle handler;
+    return com::lib::loadFunction<int (com::Anymap), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+BoolFunc LoadPred(std::string lib, std::string func) {
+    DllHandle handler;
+    return com::lib::loadFunction<int (com::Anymap), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+BoolListFunc LoadSelector(std::string lib, std::string func){
+    DllHandle handler;
+    return com::lib::loadFunction<std::list<bool> (com::Anymap), DllHandle>(lib.c_str(), func.c_str(), handler);
+}
+
+
+int main(int argc, char const *argv[])
+{
+    auto data = com::Anymap();
+    auto predFunc = LoadPred("libprinters", "ReturnTrue"); 
+    auto entrFunc = LoadEntry("libprinters", "PrintHello");
+    auto selector = LoadSelector("libprinters", "ThreeTrue");
+    std::list<bool> ST_selector_val;
+    if (!predFunc(data)) {
+        std::cout<<"Predicate returned FALSE on state ${}\n"; 
+        goto TERM;
+    }
+    entrFunc(data);
+
+SELECTOR:
+    ST_selector_val = selector(data);
+    for (int i=0; i<ST_selector_val.size(); i++) {
+        std::thread thr();
+        goto TERM;
+        //if (ST_selector_val.begin+0) {
+        //    ST_selector_val.begin+0 = !ST_selector_val.begin+0;
+        //    goto TERM;
+        //}
+        //if (ST_selector_val.begin+1) {
+        //    ST_selector_val.begin+1 = !ST_selector_val.begin+1;
+        //    goto SELECTOR;
+        //}
+    }
+
+
+
+TERM:
+    std::cout<<"Termination!\n"; 
+    return 0;
+}
\ No newline at end of file

test_parser.py

@@ -8,41 +8,11 @@ import comsdk.parser as pars
 from comsdk.graph import *
 from comsdk.edge import Edge
 
-prsr = pars.Parser()
-graph = prsr.parse_file('./tests/adot/testsimple.adot')
+prsr = pars.Parser(tocpp=True)
+data = {"a":10} 
+gr = prsr.parse_file('./tests/adot/testsimple.adot')
+gr.run(data)
+print (data)
+print(prsr.generate_cpp())
 
-data = {"a":1, "b":1}
-graph.run(data)
-print(data)
-
-
-print(graph.generate_cpp())
-
-# root = State('root')
-# br2 = State('br2')
-# br3 = State('br3')
-# br2_sibl1 = State('br3_sibl1')
-# br2_sibl2 = State('br3_sibl2')
-# br3_sibl1 = State('br3_sibl1')
-# br3_sibl2 = State('br3_sibl2')
-# end = State('end')
-# 
-# root.connect_to(br2, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# root.connect_to(br3, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br3.connect_to(br3_sibl1, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br3.connect_to(br3_sibl2, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br2.connect_to(br2_sibl1, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br2.connect_to(br2_sibl2, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br3_sibl1.connect_to(end, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br3_sibl2.connect_to(end, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br2_sibl1.connect_to(end, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# br2_sibl2.connect_to(end, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
-# 
-# graph = Graph(root, end)
-
-
-# data = {"a":1, "b":1}
-# graph.run(data)
-# 
-# print(data)
 

tests/adot/testcycl.adot

@@ -9,6 +9,6 @@ digraph CYCLED {
     
     __BEGIN__ -> ST1 
     ST1 -> ST2 [morphism=MORPH]
-    ST2 -> ST1 [morphism=MORPH]
+    ST2 -> ST1 
     ST2 -> __END__
 }
\ No newline at end of file

tests/adot/testparal.adot

@@ -7,10 +7,13 @@ digraph SIMPLEST {
     
 
     __BEGIN__ -> ROOT
+    ROOT -> A [morphism=INCR_B]
+    A->B  [morphism=INCR_B]
     ROOT ->  BR1, BR2, BR3 [morphism=(INCR_A, INCR_A, INCR_A)]
-    BR3 -> SIBL3_BR1, SIBL3_BR2 [morphism=(INCR_A, INCR_A)]
-    BR2 -> SIBL2_BR1, SIBL2_BR2 [morphism=(INCR_A, INCR_A)]
-    SIBL3_BR1 -> SIBL3_BR1_1,  SIBL3_BR1_2 [morphism=(INCR_A, INCR_A)]
-    SIBL3_BR1_1,  SIBL3_BR1_2 -> TERM  [morphism=(INCR_A, INCR_A)]
-    BR1,  SIBL2_BR1, SIBL2_BR2, TERM, SIBL3_BR2 ->  __END__ [morphism=(INCR_A, INCR_A, INCR_A, INCR_A, INCR_A)]
+    //BR3 -> SIBL3_BR1, SIBL3_BR2 [morphism=(INCR_A, INCR_A)]
+    //BR2 -> SIBL2_BR1, SIBL2_BR2 [morphism=(INCR_A, INCR_A)]
+    //SIBL3_BR1 -> SIBL3_BR1_1,  SIBL3_BR1_2 [morphism=(INCR_A, INCR_A)]
+    //SIBL3_BR1_1,  SIBL3_BR1_2 -> TERM  [morphism=(INCR_A, INCR_A)]
+    //BR1,  SIBL2_BR1, SIBL2_BR2, TERM, SIBL3_BR2 ->  __END__ [morphism=(INCR_A, INCR_A, INCR_A, INCR_A, INCR_A)]
+    BR1, BR2, BR3 -> __END__ [morphism=(INCR_A, INCR_A, INCR_A)]
 } 
\ No newline at end of file

tests/adot/testsimple.adot

 digraph SIMPLE {
-    FUNC [module=test_funcs.simplest, entry_func=increment_a_edge]
-    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    FUNC [module=libprinters, entry_func=PrintHello]
+    PRED [module=libprinters, entry_func=ReturnTrue]
     MORPH [predicate=PRED, function=FUNC]
     __BEGIN__ ->  ST1 [morphism = MORPH]
     ST1 -> ST2 [morphism = MORPH]