Many optimizations to the request handler and number of calls

kernel/modelverse_kernel/main.py

@@ -353,8 +353,39 @@ class ModelverseKernel(object):
 
         yield [("RETURN", [func])]
 
-    def jit_compile(self, task_root, inst):
-        # Try to retrieve the suggested name.
+    def execute_jit(self, task_root, inst, taskname, params = {}, store=False, resolve=True):
+        # execute_jit
+        if resolve:
+            try:
+                inst = self.jit.body_cache[inst]
+            except KeyError:
+                body, = yield [("RD", [inst, "body"])]
+                self.jit.body_cache[inst] = body
+                inst = body
+
+        if store:
+            task_frame, =    yield [("RD", [task_root, "frame"])]
+            symbols, =       yield [("RD", [task_frame, "symbols"])]
+            dict_keys_ref, =  yield [("RDK", [symbols])]
+            if dict_keys_ref:
+                dict_keys_ref_n =   yield [("RD", [i, "name"]) for i in dict_keys_ref]
+                dict_keys =       yield [("RV", [i]) for i in dict_keys_ref_n]
+                dict_values_elem = yield [("RDN", [symbols, i]) for i in dict_keys_ref]
+                dict_values = yield [("RD", [i, "value"]) for i in dict_values_elem]
+
+                parameters = dict(zip(dict_keys, dict_values))
+                parameters.update(params)
+
+                for p in parameters.keys():
+                    if not isinstance(parameters[p], dict):
+                        parameters[p] = {'id': parameters[p]}
+                params = parameters
+                    
+        params["root"] = self.root
+        params["task_root"] = task_root
+        params["taskname"] = taskname
+        params["mvk"] = self
+
         # Have the JIT compile the function.
         if inst is None:
             suggested_name = self.jit.get_global_name(inst)
@@ -363,7 +394,7 @@ class ModelverseKernel(object):
             raise ValueError('body_id cannot be None: ' + str(suggested_name))
 
         elif inst in self.jit.jitted_entry_points:
-            yield [("RETURN", [self.jit.jit_globals[self.jit.jitted_entry_points[inst]]])]
+            compiled_func = self.jit.jit_globals[self.jit.jitted_entry_points[inst]]
         else:
             compiled_func = self.jit.lookup_compiled_body(inst)
 
@@ -372,57 +403,11 @@ class ModelverseKernel(object):
                 if suggested_name is None:
                     suggested_name = "func_%s" % str(inst)
                 compiled_func, = yield [("CALL_ARGS", [self.read_function, (inst, suggested_name)])]
-                exec(compiled_func, self.jit.jit_globals)
-                compiled_func = self.jit.jit_globals[suggested_name]
+                compiled_func = self.merge_function(compiled_func, suggested_name)
                 self.jit.register_compiled(inst, compiled_func, suggested_name)
 
-            yield [("RETURN", [compiled_func])]
-
-    def execute_jit(self, task_root, inst, taskname, params = {}, store=False, resolve=True):
-        # execute_jit
-        if resolve:
-            try:
-                body = self.jit.body_cache[inst]
-            except KeyError:
-                body, = yield [("RD", [inst, "body"])]
-                self.jit.body_cache[inst] = body
-            inst = body
-
-        if store:
-            try:
-                task_frame, =    yield [("RD", [task_root, "frame"])]
-                symbols, =       yield [("RD", [task_frame, "symbols"])]
-                dict_keys_ref, =  yield [("RDK", [symbols])]
-                if dict_keys_ref:
-                    dict_keys_ref_n =   yield [("RD", [i, "name"]) for i in dict_keys_ref]
-                    dict_keys =       yield [("RV", [i]) for i in dict_keys_ref_n]
-                    dict_values_elem = yield [("RDN", [symbols, i]) for i in dict_keys_ref]
-                    dict_values = yield [("RD", [i, "value"]) for i in dict_values_elem]
-
-                    parameters = dict(zip(dict_keys, dict_values))
-                    parameters.update(params)
-                else:
-                    parameters = params
-            except:
-                parameters = params
-        else:
-            parameters = params
-
-        for p in parameters.keys():
-            if not isinstance(parameters[p], dict):
-                parameters[p] = {'id': parameters[p]}
-                #print("CONVERSION REQUIRED...")
-        #print("Calling with parameters:" + str(parameters))
-
-        parameters["root"] = self.root
-        parameters["task_root"] = task_root
-        parameters["taskname"] = taskname
-        parameters["mvk"] = self
-
-        # Have the JIT compile the function.
-        compiled_func, = yield [("CALL_ARGS", [self.jit_compile, (task_root, inst)])]
         # Run the compiled function.
-        results = yield [("CALL_KWARGS", [compiled_func, parameters])]
+        results = yield [("CALL_KWARGS", [compiled_func, params])]
         if results is None:
             raise Exception("%s: primitive finished without returning a value!" % (self.debug_info[taskname]))
         else:
@@ -463,6 +448,10 @@ class ModelverseKernel(object):
             yield [("RETURN", [result])]
         yield [("RETURN", [None])]
 
+    def merge_function(self, func, name):
+        exec(func, self.jit.jit_globals)
+        return self.jit.jit_globals[name]
+
     ########################################
     ### Execute input and output methods ###
     ########################################

kernel/modelverse_kernel/request_handler.py

@@ -19,28 +19,19 @@ class RequestHandler(object):
     def handle_request(self, reply):
         self.reply = reply
         while self.generator_stack:
-            try:
-                requests = self.generator_stack[-1].send(self.reply)
-
-                # Generated new request, so process
-                if requests and requests[0][0] in self.handlers:
-                    # This next command potentially raises a finished message already, meaning that we should stop already
-                    # We avoid an extra try/except block by putting the None on the stack already
-                    self.reply = None
-                    self.handlers[requests[0][0]](requests[0][1])
-                else:
-                    # MvS request, so forward that instead
-                    return requests
-
-            except StopIteration:
-                # Exception, so finished execution of this generator, passing on None to the caller
-                #print("STOP for " + str(self.generator_stack))
-                del self.generator_stack[-1]
-                self.reply = [None]
+            requests = self.generator_stack[-1].send(self.reply)
+
+            # Generated new request, so process
+            if requests and requests[0][0] in self.handlers:
+                # This next command potentially raises a finished message already, meaning that we should stop already
+                # We avoid an extra try/except block by putting the None on the stack already
+                self.handlers[requests[0][0]](requests[0][1])
+            else:
+                # MvS request, so forward that instead
+                return requests
                 
     def execute_finish(self, request_args):
-        del self.generator_stack[-1]
-        self.reply = [None]
+        self.generator_stack = []
         
     def execute_sleep(self, request_args):
         raise primitive_functions.SleepKernel(request_args[0], request_args[1])
@@ -51,9 +42,14 @@ class RequestHandler(object):
 
     def execute_call(self, request_args):
         self.generator_stack.append(request_args[0])
+        self.reply = None
 
     def execute_call_args(self, request_args):
+        print("CALL " + str(request_args[0]))
         self.generator_stack.append(request_args[0](*(request_args[1])))
+        self.reply = None
 
     def execute_call_kwargs(self, request_args):
+        print("KWCALL " + str(request_args[0]))
         self.generator_stack.append(request_args[0](**(request_args[1])))
+        self.reply = None

wrappers/modelverse_SCCD.py

@@ -1,7 +1,7 @@
 """
 Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
 
-Date:   Wed May  2 11:10:29 2018
+Date:   Wed May  2 14:22:40 2018
 
 Model author: Yentl Van Tendeloo
 Model name:   MvK Server