jonathanvdc
/
modelverse
forked from yentl/modelverse


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
							<class name="MvKController">
    <relationships>
        <association name="to_mvi" class="Server" min="1" max="1"/>
    </relationships>
    <constructor>
        <parameter name="params"/>
        <body>
            <![CDATA[
            self.mvs = ModelverseState("../bootstrap/bootstrap.m.gz")
            # Enable Garbage Collection
            self.mvs.GC = True
            self.root = self.mvs.read_root()[0]

            # Instantiate the kernel.
            self.mvk = ModelverseKernel(self.root)

            # Parse kernel-related options
            default_kernel_type = 'adaptive-jit'
            kernel_opts = [default_kernel_type]
            for parameter in params:
                if parameter.startswith('--kernel='):
                    kernel_opts = parameter[len('--kernel='):].split(',')
                elif parameter.startswith('--jit-timing-log='):
                    output_file = open(parameter[len('--jit-timing-log='):], 'w')
                    def log_line(line):
                        output_file.write(line + '\n')
                        output_file.flush()
                    self.mvk.jit.set_jit_timing_log(log_line)

            for opt in kernel_opts:
                if opt == 'legacy-interpreter':
                    self.mvk = LegacyModelverseKernel(self.root)
                elif opt == 'interpreter':
                    self.mvk.jit.set_jit_enabled(False)
                elif opt == 'no-thunks':
                    self.mvk.jit.enable_thunks(False)
                elif opt == 'thunks':
                    self.mvk.jit.enable_thunks()
                elif opt == 'no-source-maps':
                    self.mvk.jit.enable_source_maps(False)
                elif opt == 'source-maps':
                    self.mvk.jit.enable_source_maps()
                elif opt == 'no-insert-nops':
                    self.mvk.jit.enable_nop_insertion(False)
                elif opt == 'insert-nops':
                    self.mvk.jit.enable_nop_insertion()
                elif opt == 'trace':
                    self.mvk.jit.enable_tracing()
                elif opt == 'bytecode-interpreter':
                    self.mvk.jit.set_function_body_compiler(jit.compile_function_body_interpret)
                elif opt == 'baseline-jit':
                    self.mvk.jit.set_function_body_compiler(jit.compile_function_body_baseline)
                elif opt == 'fast-jit':
                    self.mvk.jit.set_function_body_compiler(jit.compile_function_body_fast)
                elif opt == 'adaptive-jit-favor-large-functions':
                    self.mvk.jit.set_function_body_compiler(
                            lambda *args: jit.compile_function_body_adaptive(
                                *args, temperature_heuristic=jit.favor_large_functions))
                elif opt == 'adaptive-jit-favor-small-functions':
                    self.mvk.jit.set_function_body_compiler(
                        lambda *args: jit.compile_function_body_adaptive(
                            *args, temperature_heuristic=jit.favor_small_functions))
                elif opt == 'adaptive-jit-favor-loops':
                    self.mvk.jit.set_function_body_compiler(
                        lambda *args: jit.compile_function_body_adaptive(
                            *args, temperature_heuristic=jit.favor_loops))
                elif opt == 'adaptive-jit' or opt == 'adaptive-jit-favor-small-loops':
                    self.mvk.jit.set_function_body_compiler(
                        lambda *args: jit.compile_function_body_adaptive(
                            *args, temperature_heuristic=jit.favor_small_loops))
                else:
                    print("warning: unknown kernel option '%s'." % opt)

            self.all_failed = False
            self.timeout = False
            self.init_time = time.time()

            self.tasks = set()
            self.input_queue = defaultdict(list)
            self.output_queue = defaultdict(list)
            self.source = None
            self.port = int(sys.argv[1])
            self.count = 0
            
            self.debugged_tasks = set()
            self.debug_info = {}
            self.done_something = False

            self.mvs_operations = {
                    "CN": self.mvs.create_node,
                    "CE": self.mvs.create_edge,
                    "CNV": self.mvs.create_nodevalue,
                    "CD": self.mvs.create_dict,

                    "RV": self.mvs.read_value,
                    "RO": self.mvs.read_outgoing,
                    "RI": self.mvs.read_incoming,
                    "RE": self.mvs.read_edge,
                    "RD": self.mvs.read_dict,
                    "RDN": self.mvs.read_dict_node,
                    "RDNE": self.mvs.read_dict_node_edge,
                    "RDE": self.mvs.read_dict_edge,
                    "RRD": self.mvs.read_reverse_dict,
                    "RR": self.mvs.read_root,
                    "RDK": self.mvs.read_dict_keys,

                    "DE": self.mvs.delete_edge,
                    "DN": self.mvs.delete_node,
                }

            self.execute_modelverse("", "load_primitives", [])
            ]]>
        </body>
    </constructor>

    <method name="execute_modelverse">
        <parameter name="taskname"/>
        <parameter name="operation"/>
        <parameter name="params"/>
        <body>
            <![CDATA[
            reply = None
            commands = []
            try:
                while 1:
                    commands = self.mvk.execute_yields(taskname, operation, params, reply)
                    if commands is None:
                        break
                    reply = [self.mvs_operations[command[0]](*(command[1]))[0] for command in commands]
                    #for c, r in zip(commands, reply):
                    #    print("%s --> %s" % (c, r))
            except:
                print("ERROR: " + str(self.mvk.debug_info.get(taskname, "Unknown taskname")))
                raise
            ]]>
        </body>
    </method>

    <scxml initial="init_server">
        <state id="init_server">
            <onentry>
                <raise scope="cd" event="create_instance">
                    <parameter expr="'to_mvi'"/>
                    <parameter expr="'Server'"/>
                    <parameter expr="''"/>
                    <parameter expr="self.port"/>
                </raise>
            </onentry>
            <transition event="instance_created" target="../running">
                <parameter name="instancename"/>
                <raise scope="cd" event="start_instance">
                    <parameter expr="instancename"/>
                </raise>
            </transition>
        </state>

        <parallel id="running">
            <state id="wait_for_requests">
                <state id="wait">
                    <transition event="from_mvi" target=".">
                        <parameter name="source"/>
                        <parameter name="data"/>
                        <script>
                            # No JSON encoding necessary, as it is not complex
                            try:
                                self.done_something = False
                                if data["op"] == "set_input":
                                    if "value" in data:
                                        value = [json.loads(data["value"])]
                                    else:
                                        value = json.loads(data["data"])
                                    self.input_queue[data["taskname"]].append((source, value))
                                elif data["op"] == "get_output":
                                    self.output_queue[data["taskname"]].append(source)
                                elif data["op"] == "attach_debugger":
                                    self.debugged_tasks.add(data["taskname"])
                                    self.done_something = True
                                    self.source = source
                                    self.debug_info[data["taskname"]] = {'state': 'running', 'breakpoints': []}
                                elif data["op"] == "detach_debugger":
                                    self.debugged_tasks.discard(data["taskname"])
                                    self.done_something = True
                                    self.source = source
                                    del self.debug_info[data["taskname"]]
                                elif data["op"] == "pause":
                                    if data["taskname"] in self.debugged_tasks:
                                        self.debug_info[data["taskname"]]['state'] = 'paused'
                                    self.done_something = True
                                    self.source = source
                                elif data["op"] == "resume":
                                    if data["taskname"] in self.debugged_tasks:
                                        self.debug_info[data["taskname"]]['state'] = 'running'
                                    self.done_something = True
                                    self.source = source
                                elif data["op"] == "step_over":
                                    pass
                                    self.done_something = True
                                    self.source = source
                                elif data["op"] == "step_into":
                                    pass
                                    self.done_something = True
                                    self.source = source
                                else:
                                    raise Exception("DROPPING unknown operation: " + str(data["op"]))
                            except ValueError:
                                print("Error when deserializing request: " + str(data))
                                raise
                        </script>
                    </transition>

                    <transition cond="self.done_something" target=".">
                        <raise event="HTTP_input" scope="narrow" target="'to_mvi/%s' % self.source">
                            <parameter expr="json.dumps(True)"/>
                        </raise>
                        <script>
                            self.done_something = False
                        </script>
                    </transition>
                </state>
            </state>

            <state id="execution" initial="execution">
                <state id="execution">
                    <onentry>
                        <script>
                            self.outputs = []
                            self.timeout = False
                            if self.tasks:
                                task = self.tasks.pop()
                                if not task in self.debugged_tasks or self.debug_info[task]['state'] == 'running':
                                    # Check if there are values to input
                                    while self.input_queue[task]:
                                        source, args = self.input_queue[task].pop(0)
                                        for args_entry in args:
                                            self.execute_modelverse(task, "set_input", [args_entry])

                                        self.outputs.append((source, "OK"))
                                        self.all_failed = False

                                    nr_of_steps = 1 if task in self.debugged_tasks else 100
                                    # Now process for some steps, or until we are again blocked for input
                                    for x in xrange(nr_of_steps):
                                        self.execute_modelverse(task, "execute_rule", [])

                                        if not self.mvk.success:
                                            # Blocking or broken, so quit already to stop wasting CPU
                                            break

                                        # Could at least execute one instruction, so mark it as "not failed"
                                        self.all_failed = False

                                    # Perform output if there is anything
                                    while self.output_queue[task]:
                                        self.execute_modelverse(task, "get_output", [])
                                        if self.mvk.success:
                                            self.outputs.append((self.output_queue[task].pop(0), self.mvk.returnvalue))
                                            self.all_failed = False
                                        else:
                                            break

                            else:
                                if self.count >= 2000:
                                    self.count = 0
                                    self.mvs.purge()
                                else:
                                    self.count += 1
                                    self.mvs.garbage_collect()
                                out = self.mvs.read_outgoing(self.root)[0]
                                for m in out:
                                    src, task = self.mvs.read_edge(m)[0]
                                    outgoing = self.mvs.read_outgoing(m)[0]
                                    first = self.mvs.read_edge(outgoing[0])[0]
                                    dest = first[1]
                                    name = self.mvs.read_value(dest)[0]
                                    if name.startswith("__"):
                                        continue
                                    self.tasks.add(name)
                                self.timeout = self.all_failed
                                self.all_failed = True
                        </script>
                    </onentry>

                    <transition cond="self.outputs" after="self.sccd_yield()" target="../process_data"/>

                    <transition cond="self.timeout and not self.outputs" after="self.sccd_yield() + 0.10" target="."/>

                    <transition cond="not self.timeout and not self.outputs" after="self.sccd_yield()" target="."/>
                </state>

                <state id="process_data">
                    <transition cond="self.outputs" target=".">
                        <script>
                            destination, value = self.outputs.pop()
                        </script>
                        <raise event="HTTP_input" scope="narrow" target="'to_mvi/%s' % destination">
                            <parameter expr="json.dumps(value)"/>
                        </raise>
                    </transition>

                    <transition cond="not self.outputs" target="../execution"/>
                </state>
            </state>

            <state id="remove_sockets">
                <state id="remove_sockets">
                    <transition event="delete_socket" target=".">
                        <parameter name="socket"/>
                        <script>
                            for task in self.output_queue.keys():
                                self.output_queue[task] = [s for s in self.output_queue[task] if s != socket]
                        </script>
                    </transition>
                </state>
            </state>
        </parallel>
    </scxml>
</class>