Naively changed user to task in all files

README.md

@@ -11,7 +11,7 @@ Starting up the Modelverse
 
 Starting up the Modelverse is easy: simply execute the `scripts/run_local_modelverse.py` script, with as parameter the port you want to use.
 This will compile the Modelverse statechart and execute it afterwards.
-You can now directly communicate with the Modelverse user initialisation layer.
+You can now directly communicate with the Modelverse task initialisation layer.
 It is not recommended that you do this manually, so we will now introduce the action language.
 
 Compiling Action Language
@@ -20,18 +20,18 @@ Compiling Action Language
 For a more user-friendly experience, an Action Language compiler was introduced that can automatically generate Modelverse instructions.
 During compilation, a live Modelverse is required, as the bytecodes are immediately uploaded after compilation.
 The Modelverse uses a traditional compilation phase and linking phase, though this is all hidden to the user through the `scripts/make_all.py` script.
-The script takes as parameter the address of the Modelverse, the username in whose name to execute the code, and a list of source files.
+The script takes as parameter the address of the Modelverse, the taskname with which to communicate, and a list of source files.
 For realistic applications, we recommend to always link to the bootstrap code, by including the file `bootstrap/\*.alc`.
 Even on systems that don't support globbing (e.g., Windows), this will automatically be expanded by the compiler.
 
 For example, to compile the simple textual interface, you must compile the interface's action language, together with all bootstrapping code (the libraries):
 
 ```sh
-python scripts/make_all.py http://127.0.0.1:8001 test_user bootstrap/*.alc integration/code/pn_interface.alc
+python scripts/make_all.py http://127.0.0.1:8001 test_task bootstrap/*.alc integration/code/pn_interface.alc
 ```
 
 Compilation is (relatively) smart, as it will not compile code again that is already present in the Modelverse.
-As such, except for the first user, the bootstrap code no longer needs to be compiled, only linked.
+As such, except for the first task, the bootstrap code no longer needs to be compiled, only linked.
 In the future, this is expected to become more user friendly for users, such that they no longer need to have the bootstrapping code available locally.
 
 After this part, your action language in `integration/code/pn_interface.alc` is compiled and running on the Modelverse.
@@ -45,7 +45,6 @@ To do this, you can use whatever tool you want, as long as it can send and recei
 For example, a mere internet browser can already communicate with the Modelverse, though not in the most user-friendly way.
 
 A nicer way is through the Python prompt script `scripts/prompt.py`.
-It will ask you the location of the Modelverse, and the user to connect to.
 After that, it will print out all the output of the Modelverse, and send in all your queries directly to the Modelverse.
 
 Performance

bootstrap/bootstrap.py

@@ -7,18 +7,18 @@ import gzip
 def bootstrap():
     root = ["__hierarchy"]
 
-    user_manager = "user_manager"
+    task_manager = "task_manager"
     initial_code_manager = "bootstrap/initial_code_manager.alb"
-    initial_code_user = "bootstrap/initial_code_user.alb"
-    bootstrap_files = glob.glob("bootstrap/*.alc") + [initial_code_manager, initial_code_user]
+    initial_code_task = "bootstrap/initial_code_task.alb"
+    bootstrap_files = glob.glob("bootstrap/*.alc") + [initial_code_manager, initial_code_task]
 
-    user_data = [   "input",
+    task_data = [   "input",
                     "output",
                     "globals",
                     "frame",
                     ]
 
-    user_frame = [  "evalstack",
+    task_frame = [  "evalstack",
                     "symbols",
                     "returnvalue",
                     ]
@@ -102,7 +102,7 @@ def bootstrap():
                     "element_eq": ["Boolean", "Element", "Element"],
                     "element_neq": ["Boolean", "Element", "Element"],
                     "read_root": ["Element"],
-                    "read_userroot": ["Element"],
+                    "read_taskroot": ["Element"],
                     "deserialize": ["Element", "String"],
                     "log": ["String", "String"],
                     "time": ["Float"],
@@ -179,31 +179,31 @@ def bootstrap():
                 declare_primitive_class('primitives', primitives)
                 declare_primitive_class('jit', jit_primitives)
 
-                # Create the initial user
-                f.write("Node user_root()\n")
+                # Create the initial task
+                f.write("Node task_root()\n")
 
-                for data in user_data:
-                    f.write("Node user_%s()\n" % data)
-                    f.write('Node ___user_%s("%s")\n' % (data, data))
-                    f.write("Edge _user_%s(user_root, user_%s)\n" % (data, data))
-                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in task_data:
+                    f.write("Node task_%s()\n" % data)
+                    f.write('Node ___task_%s("%s")\n' % (data, data))
+                    f.write("Edge _task_%s(task_root, task_%s)\n" % (data, data))
+                    f.write("Edge __task_%s(_task_%s, ___task_%s)\n" % (data, data, data))
 
-                for data in user_frame:
-                    f.write("Node user_%s()\n" % data)
-                    f.write('Node ___user_%s("%s")\n' % (data, data))
-                    f.write("Edge _user_%s(user_frame, user_%s)\n" % (data, data))
-                    f.write("Edge __user_%s(_user_%s, ___user_%s)\n" % (data, data, data))
+                for data in task_frame:
+                    f.write("Node task_%s()\n" % data)
+                    f.write('Node ___task_%s("%s")\n' % (data, data))
+                    f.write("Edge _task_%s(task_frame, task_%s)\n" % (data, data))
+                    f.write("Edge __task_%s(_task_%s, ___task_%s)\n" % (data, data, data))
 
                 # Add last_input and last_output links
                 for data in ["input", "output"]:
-                    f.write('Node ___user_last_%s("last_%s")\n' % (data, data))
-                    f.write("Edge _user_last_%s(user_root, user_%s)\n" % (data, data))
-                    f.write("Edge __user_last_%s(_user_last_%s, ___user_last_%s)\n" % (data, data, data))
+                    f.write('Node ___task_last_%s("last_%s")\n' % (data, data))
+                    f.write("Edge _task_last_%s(task_root, task_%s)\n" % (data, data))
+                    f.write("Edge __task_last_%s(_task_last_%s, ___task_last_%s)\n" % (data, data, data))
                     
-                # Bind user to the root
-                f.write('Node ___new_user("%s")\n' % user_manager)
-                f.write("Edge _new_user(root, user_root)\n")
-                f.write("Edge __new_user(_new_user, ___new_user)\n")
+                # Bind task to the root
+                f.write('Node ___new_task("%s")\n' % task_manager)
+                f.write("Edge _new_task(root, task_root)\n")
+                f.write("Edge __new_task(_new_task, ___new_task)\n")
 
                 def compile_code_AL(filename, target, prepend="", main=False, symbols=None):
                     import sys
@@ -225,7 +225,7 @@ def bootstrap():
                     bootstrap_file = bootstrap_file.replace("\\", "/")
                     print("[COMP] %s" % bootstrap_file)
                     symbols = {}
-                    f.write(compile_code_AL(bootstrap_file, "initial_IP", prepend=bootstrap_file, symbols=symbols, main = bootstrap_file in [initial_code_manager, initial_code_user]), both=False)
+                    f.write(compile_code_AL(bootstrap_file, "initial_IP", prepend=bootstrap_file, symbols=symbols, main = bootstrap_file in [initial_code_manager, initial_code_task]), both=False)
 
                     # Now link the code with the compilation manager structure
                     f.write("Node elem()\n", both=False)
@@ -253,22 +253,22 @@ def bootstrap():
                         f.write('Edge _(__symbols, v)\n', both=False)
                         f.write('Edge _(_, k)\n', both=False)
 
-                # Create code for initial user
-                print("[BOOT] user_manager")
+                # Create code for initial task
+                print("[BOOT] task_manager")
                 f.write('Node _IP_str("IP")\n', both=False)
-                f.write("Edge _user_frame(user_frame, %s_initial_IP)\n" % initial_code_manager, both=False)
-                f.write("Edge __user_frame(_user_frame, _IP_str)\n", both=False)
+                f.write("Edge _task_frame(task_frame, %s_initial_IP)\n" % initial_code_manager, both=False)
+                f.write("Edge __task_frame(_task_frame, _IP_str)\n", both=False)
 
                 f.write('Node __phase("init")\n', both=False)
                 f.write('Node __phase_str("phase")\n', both=False)
-                f.write("Edge _user_phase(user_frame, __phase)\n", both=False)
-                f.write("Edge __user_phase(_user_phase, __phase_str)\n", both=False)
+                f.write("Edge _task_phase(task_frame, __phase)\n", both=False)
+                f.write("Edge __task_phase(_task_phase, __phase_str)\n", both=False)
 
-                # Create code for new users to start at
-                print("[BOOT] new_user")
+                # Create code for new tasks to start at
+                print("[BOOT] new_task")
                 f.write('Node __IP_str("__IP")\n', both=False)
-                f.write("Edge _user_IP(__hierarchy, %s_initial_IP)\n" % initial_code_user, both=False)
-                f.write("Edge __user_IP(_user_IP, __IP_str)\n", both=False)
+                f.write("Edge _task_IP(__hierarchy, %s_initial_IP)\n" % initial_code_task, both=False)
+                f.write("Edge __task_IP(_task_IP, __IP_str)\n", both=False)
     except:
         os.remove("bootstrap/bootstrap.m.gz")
         os.remove("bootstrap/minimal.m.gz")

bootstrap/ftg.alc

@@ -1,54 +0,0 @@
-include "primitives.alh"
-include "modelling.alh"
-include "library.alh"
-
-Void function visit_ftg(ftg : Element, root : Element, path : String, current : Element):
-	log("Visit FTG: " + path)
-	if (dict_in(current, "source")):
-		// Is a transformation, and therefore an edge for the FTG
-		if (bool_not(dict_in(ftg["model"], path))):
-			if (bool_not(dict_in(ftg["model"], current["source"]))):
-				visit_ftg(ftg, root, current["source"], root[current["source"]])
-
-			if (bool_not(dict_in(ftg["model"], current["target"]))):
-				visit_ftg(ftg, root, current["target"], root[current["source"]])
-
-			instantiate_link(ftg, "Transformation", path, current["source"], current["target"])
-			instantiate_attribute(ftg, path, "location", path)
-	else:
-		// Is a model, and therefore a node for the FTG
-		if (bool_not(dict_in(ftg["model"], path))):
-			instantiate_node(ftg, "Formalism", path)
-			instantiate_attribute(ftg, path, "location", path)
-
-	return !
-
-Element function create_ftg(root : Element):
-	Element queue
-	Element current
-	Element submodels
-	Element ftg
-	String path
-	String submodel
-
-	queue = create_node()
-	set_add(queue, create_tuple("models", root))
-	ftg = instantiate_model(import_node("models/FTG"))
-
-	while (read_nr_out(queue) > 0):
-		current = set_pop(queue)
-		path = current[0]
-		current = current[1]
-		log("Check node: " + cast_e2s(current))
-		if (dict_in(current, "__hierarchy_node" )):
-			log("IS HIERARCHY: " + path)
-			submodels = dict_keys(current)
-			// Is a browser structure, and therefore not part of the FTG
-			while (read_nr_out(submodels) > 0):
-				submodel = set_pop(submodels)
-				set_add(queue, create_tuple((path + "/") + submodel, current[submodel]))
-		else:
-			log("IS MODEL: " + path)
-			visit_ftg(ftg, root, path, current)
-
-	return ftg!

bootstrap/initial_code_manager.alb

@@ -1,10 +1,10 @@
 include "bootstrap/primitives.alc"
-include "user_manager.alh"
+include "task_manager.alh"
 
 Void function __main():
 	Element root
 	root = read_root()
 	root = root["__hierarchy"]["objects"]
-	exec(root["bootstrap/user_manager.alc"]["initializers"])
-	user_management()
+	exec(root["bootstrap/task_manager.alc"]["initializers"])
+	task_management()
 	return!

bootstrap/initial_code_user.alb

@@ -1,5 +1,5 @@
 include "bootstrap/primitives.alc"
-include "user_interface.alh"
+include "task_interface.alh"
 
 Void mutable function __main():
 	Element root
@@ -12,6 +12,6 @@ Void mutable function __main():
 	exec(root["bootstrap/conformance_scd.alc"]["initializers"])
 	exec(root["bootstrap/metamodels.alc"]["initializers"])
 	exec(root["bootstrap/modelling.alc"]["initializers"])
-	exec(root["bootstrap/user_interface.alc"]["initializers"])
-	new_user()
+	exec(root["bootstrap/task_interface.alc"]["initializers"])
+	new_task()
 	return!

bootstrap/primitives.alc

@@ -74,7 +74,7 @@ Integer function string_len(a: String) = ?primitives/string_len
 Element function deserialize(a: String) = ?primitives/deserialize
 Element function log(a: String) = ?primitives/log
 Element function read_root() = ?primitives/read_root
-Element function read_userroot() = ?primitives/read_userroot
+Element function read_taskroot() = ?primitives/read_taskroot
 Boolean function is_physical_int(a: Element) = ?primitives/is_physical_int
 Boolean function is_physical_float(a: Element) = ?primitives/is_physical_float
 Boolean function is_physical_string(a: Element) = ?primitives/is_physical_string
@@ -164,16 +164,16 @@ String function string_substr(a: String, b: Integer, c: Integer):
 Element function resolve(name : String):
 	// Could directly access it through introspection
 	// But seems safer to create some code and execute it...
-	Element user_root
-	user_root = read_userroot()
-	user_root = user_root["globals"][name]["value"]
-	return user_root!
+	Element task_root
+	task_root = read_taskroot()
+	task_root = task_root["globals"][name]["value"]
+	return task_root!
 
 Integer function integer_modulo(a : Integer, b : Integer):
 	return a - b * (a / b)!
 
 Boolean function has_input():
-	return (element_neq(dict_read(read_userroot(), "input"), dict_read(read_userroot(),"last_input")))!
+	return (element_neq(dict_read(read_taskroot(), "input"), dict_read(read_taskroot(),"last_input")))!
 
 Element function list_pop(lst : Element, index : Integer):
 	Element v

bootstrap/user_interface.alc

@@ -5,7 +5,7 @@ include "compilation_manager.alh"
 include "constructors.alh"
 include "modelling.alh"
 
-Void mutable function new_user():
+Void mutable function new_task():
 	Integer interface
 	while (True):
 		interface = input()

bootstrap/task_manager.alc

@@ -0,0 +1,32 @@
+include "io.alh"
+include "primitives.alh"
+
+Void function task_management():
+	String taskname
+	Element task_root
+	Element task_frame
+	Element output_value
+	Element input_value
+	
+	while (True):
+		taskname = input()
+		if (bool_not(dict_in(read_root(), taskname))):
+			task_root = create_node()
+			task_frame = create_node()
+			output_value = create_node()
+			input_value = create_node()
+			dict_add(task_root, "frame", task_frame)
+			dict_add(task_root, "globals", create_node())
+			dict_add(task_root, "output", output_value)
+			dict_add(task_root, "last_output", output_value)
+			dict_add(task_root, "input", input_value)
+			dict_add(task_root, "last_input", input_value)
+			dict_add(task_frame, "evalstack", create_node())
+			dict_add(task_frame, "returnvalue", create_node())
+			dict_add(task_frame, "phase", "init")
+			dict_add(task_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
+			dict_add(task_frame, "symbols", create_node())
+
+			//Add this only at the end, as otherwise the task will already be detected
+			dict_add(read_root(), taskname, task_root)
+	return!

bootstrap/user_manager.alc

@@ -1,32 +0,0 @@
-include "io.alh"
-include "primitives.alh"
-
-Void function user_management():
-	String username
-	Element user_root
-	Element user_frame
-	Element output_value
-	Element input_value
-	
-	while (True):
-		username = input()
-		if (bool_not(dict_in(read_root(), username))):
-			user_root = create_node()
-			user_frame = create_node()
-			output_value = create_node()
-			input_value = create_node()
-			dict_add(user_root, "frame", user_frame)
-			dict_add(user_root, "globals", create_node())
-			dict_add(user_root, "output", output_value)
-			dict_add(user_root, "last_output", output_value)
-			dict_add(user_root, "input", input_value)
-			dict_add(user_root, "last_input", input_value)
-			dict_add(user_frame, "evalstack", create_node())
-			dict_add(user_frame, "returnvalue", create_node())
-			dict_add(user_frame, "phase", "init")
-			dict_add(user_frame, "IP", dict_read(dict_read(read_root(), "__hierarchy"), "__IP"))
-			dict_add(user_frame, "symbols", create_node())
-
-			//Add this only at the end, as otherwise the user will already be detected
-			dict_add(read_root(), username, user_root)
-	return!

core/core_algorithm.alc

@@ -197,6 +197,14 @@ Boolean function check_login(user_id : String):
 
 	return password == stored_password!
 
+Element function extract_ftg(user_id : String):
+	// Extract your personal FTG, showing only the readable models that can be opened
+	// This function does the actual projection of transformations
+
+	// TODO: Only keep transformations satisfying some properties!
+
+	return create_node()!
+
 Element function user_function():
 	String username
 	String user_id

hybrid_server/classes/mvkcontroller.xml

@@ -34,14 +34,14 @@
             self.timeout = False
             self.init_time = time.time()
 
-            self.users = set()
+            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_users = set()
+            self.debugged_tasks = set()
             self.debug_info = {}
             self.done_something = False
 
@@ -73,7 +73,7 @@
     </constructor>
 
     <method name="execute_modelverse">
-        <parameter name="username"/>
+        <parameter name="taskname"/>
         <parameter name="operation"/>
         <parameter name="params"/>
         <body>
@@ -81,7 +81,7 @@
             reply = None
             commands = []
             while 1:
-                commands = self.mvk.execute_yields(username, operation, params, reply)
+                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]
@@ -124,27 +124,27 @@
                                         value = [json.loads(data["value"])]
                                     else:
                                         value = json.loads(data["data"])
-                                    self.input_queue[data["username"]].append((source, value))
+                                    self.input_queue[data["taskname"]].append((source, value))
                                 elif data["op"] == "get_output":
-                                    self.output_queue[data["username"]].append(source)
+                                    self.output_queue[data["taskname"]].append(source)
                                 elif data["op"] == "attach_debugger":
-                                    self.debugged_users.add(data["username"])
+                                    self.debugged_tasks.add(data["taskname"])
                                     self.done_something = True
                                     self.source = source
-                                    self.debug_info[data["username"]] = {'state': 'running', 'breakpoints': []}
+                                    self.debug_info[data["taskname"]] = {'state': 'running', 'breakpoints': []}
                                 elif data["op"] == "detach_debugger":
-                                    self.debugged_users.discard(data["username"])
+                                    self.debugged_tasks.discard(data["taskname"])
                                     self.done_something = True
                                     self.source = source
-                                    del self.debug_info[data["username"]]
+                                    del self.debug_info[data["taskname"]]
                                 elif data["op"] == "pause":
-                                    if data["username"] in self.debugged_users:
-                                        self.debug_info[data["username"]]['state'] = 'paused'
+                                    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["username"] in self.debugged_users:
-                                        self.debug_info[data["username"]]['state'] = 'running'
+                                    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":
@@ -180,23 +180,23 @@
                         <script>
                             self.timeout = False
                             self.destination = None
-                            if self.users:
-                                user = self.users.pop()
-                                if not user in self.debugged_users or self.debug_info[user]['state'] == 'running':
+                            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
-                                    if self.input_queue[user]:
-                                        source, args = self.input_queue[user].pop(0)
+                                    if self.input_queue[task]:
+                                        source, args = self.input_queue[task].pop(0)
                                         for args_entry in args:
-                                            self.execute_modelverse(user, "set_input", [args_entry])
+                                            self.execute_modelverse(task, "set_input", [args_entry])
 
                                         self.destination = source
                                         self.value = "OK"
                                         self.all_failed = False
 
-                                    nr_of_steps = 1 if user in self.debugged_users else 100
+                                    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(user, "execute_rule", [])
+                                        self.execute_modelverse(task, "execute_rule", [])
 
                                         if not self.mvk.success:
                                             # Blocking or broken, so quit already to stop wasting CPU
@@ -208,10 +208,10 @@
                                     # Check that we don't have anything to output yet, otherwise we wait
                                     if self.destination is None:
                                         # Perform output if there is anything
-                                        if self.output_queue[user]:
-                                            self.execute_modelverse(user, "get_output", [])
+                                        if self.output_queue[task]:
+                                            self.execute_modelverse(task, "get_output", [])
                                             if self.mvk.success:
-                                                self.destination = self.output_queue[user].pop(0)
+                                                self.destination = self.output_queue[task].pop(0)
                                                 self.value = self.mvk.returnvalue
                                                 self.all_failed = False
 
@@ -224,14 +224,14 @@
                                     self.mvs.garbage_collect()
                                 out = self.mvs.read_outgoing(self.root)[0]
                                 for m in out:
-                                    src, user = self.mvs.read_edge(m)[0]
+                                    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.users.add(name)
+                                    self.tasks.add(name)
                                 self.timeout = self.all_failed
                                 self.all_failed = True
                         </script>
@@ -254,8 +254,8 @@
                     <transition event="delete_socket" target=".">
                         <parameter name="socket"/>
                         <script>
-                            for user in self.output_queue.keys():
-                                self.output_queue[user] = [s for s in self.output_queue[user] if s != socket]
+                            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>

integration/utils.py

@@ -16,7 +16,7 @@ sys.path.append("scripts")
 from hutn_compiler.compiler import main as do_compile
 from check_objects import to_recompile
 
-username = "test_user"
+taskname = "test_task"
 parallel_push = True
 
 ports = set()
@@ -51,7 +51,7 @@ def kill(process):
 
 def flush_data(address, data):
     if data:
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username})), timeout=10).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=10).read()
     return []
 
 def compile_file(address, mod_filename, filename, mode, proc):
@@ -59,9 +59,9 @@ def compile_file(address, mod_filename, filename, mode, proc):
     try:
         timeout_val = 240
         import random
-        username = str(random.random())
+        taskname = str(random.random())
         while 1:
-            proc2 = execute("compile", [address, mod_filename, username, filename, mode], wait=False)
+            proc2 = execute("compile", [address, mod_filename, taskname, filename, mode], wait=False)
 
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -139,7 +139,7 @@ def run_file(files, parameters, expected, mode, wait=False):
 
         if mode[-1] == "O":
             # Fire up the linker
-            val = execute("link_and_load", [address, username] + mod_files, wait=True)
+            val = execute("link_and_load", [address, taskname] + mod_files, wait=True)
             if val != 0:
                 raise Exception("Linking error")
 
@@ -149,13 +149,13 @@ def run_file(files, parameters, expected, mode, wait=False):
         # ... and wait for replies
         if expected is None:
             while 1:
-                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240).read()
+                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240).read()
                 val = json.loads(val)
                 print(val)
         for e in expected:
             c = len(e) if isinstance(e, set) else 1
             for _ in range(c):
-                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240).read()
+                val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240).read()
                 val = json.loads(val)
 
                 if proc.returncode is not None:
@@ -192,7 +192,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
         # Run Modelverse server
         proc = execute("run_local_modelverse", [str(port)], wait=False)
 
-        # Create user and set interface
+        # Create task and set interface
         timeout_val = 15
         start = time.time()
         while 1:
@@ -202,9 +202,9 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                 return False
 
             try:
-                urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": '"%s"' % username, "username": "user_manager"})), timeout=1).read()
+                urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": '"%s"' % taskname, "taskname": "task_manager"})), timeout=1).read()
                 if interface is not None:
-                    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": interface, "username": username})), timeout=1).read()
+                    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": interface, "taskname": taskname})), timeout=1).read()
                 break
             except:
                 time.sleep(0.01)
@@ -219,7 +219,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
         if link is not None:
             # Execute linker
             timeout_val = 10
-            proc2 = execute("link_and_load", [address, username] + link, wait=False)
+            proc2 = execute("link_and_load", [address, taskname] + link, wait=False)
 
             while proc2.returncode is None:
                 time.sleep(0.01)
@@ -234,7 +234,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                     return False
 
         for inp in inputs:
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": inp, "username": username})), timeout=1).read()
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "element_type": "V", "value": inp, "taskname": taskname})), timeout=1).read()
             proc.poll()
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -251,7 +251,7 @@ def run_barebone(parameters, expected, interface="0", timeout=False, wait=False,
                         # Modelverse has already terminated, which isn't a good sign!
                         return False
 
-                    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=240 if not timeout else 20).read()
+                    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=240 if not timeout else 20).read()
                     val = json.loads(val)
                 except:
                     if timeout:

interface/CBD/main.py

@@ -18,7 +18,7 @@ JUMP = 50
 MAX_WIDTH = 20 * JUMP
 MAX_HEIGHT = 20 * JUMP
 address = "http://127.0.0.1:8001"
-username = "test"
+taskname = "test"
 
 root = Tk()
 
@@ -72,7 +72,7 @@ def poll(address):
     working_simulation = None
 
     while 1:
-        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read())
+        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read())
         print("Process " + str(returnvalue))
         if (returnvalue.startswith("AVAILABLE_ATTR_VALUE")):
             working_available_attrs.append([json.loads(returnvalue.split(" ", 1)[1]), None])
@@ -110,58 +110,58 @@ class MvLayer():
         import threading
 
         self.address = address
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
         thrd = threading.Thread(target=poll, args=[address])
         thrd.daemon = True
         thrd.start()
 
     def read_available_attributes(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
 
         while not available_attrs:
             time.sleep(0.1)
         return available_attrs.pop(0)
 
     def read_attribute(self, name, attr):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
 
         while not attribute:
             time.sleep(0.1)
         return attribute.pop(0)
 
     def set_attribute(self, name, attr, value):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
 
     def instantiate_block(self, name, block_type):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def instantiate_link(self, name, link_type, source, target):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
 
     def simulate(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
 
     def step(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"step"', "taskname": taskname}))).read()
 
     def pause(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
 
     def delete(self, block):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
 
 def lower(value):
     return value / JUMP * JUMP

interface/FSA/main.py

@@ -21,7 +21,7 @@ MAX_WIDTH = 10 * JUMP
 MAX_HEIGHT = 10 * JUMP
 CLICK_TOLERANCE = 5
 address = "http://127.0.0.1:8001"
-username = "test"
+taskname = "test"
 
 root = Tk()
 names = {}
@@ -101,7 +101,7 @@ def poll(address):
     global request_new_state
 
     while 1:
-        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read())
+        returnvalue = json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read())
         print("Process " + str(returnvalue))
         if (returnvalue.startswith("AVAILABLE_ATTR_VALUE")):
             working_available_attrs.append([json.loads(returnvalue.split(" ", 1)[1]), None])
@@ -140,7 +140,7 @@ class MvLayer():
         import threading
 
         self.address = address
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
         thrd = threading.Thread(target=poll, args=[address])
         thrd.daemon = True
         thrd.start()
@@ -156,8 +156,8 @@ class MvLayer():
         thrd.start()
 
     def read_available_attributes(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_available_attributes"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
 
         while 1:
             try:
@@ -168,9 +168,9 @@ class MvLayer():
 
     def read_attribute(self, name, attr):
         print("Sending read_attribute")
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"read_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
 
         print("Waiting for attribute")
         while 1:
@@ -181,51 +181,51 @@ class MvLayer():
                 time.sleep(0.1)
 
     def set_attribute(self, name, attr, value):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"set_attribute"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % name, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % attr, "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": json.dumps(value), "taskname": taskname}))).read()
 
     def instantiate_element(self, name, block_type):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_node"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def instantiate_link(self, name, link_type, source, target):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"instantiate_association"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (link_type), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (source), "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (target), "taskname": taskname}))).read()
 
     def simulate(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"simulate"', "taskname": taskname}))).read()
 
     def pause(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"pause"', "taskname": taskname}))).read()
 
     def send_event(self, event):
         print("SENDING EVENT")
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"event"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (event), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"event"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (event), "taskname": taskname}))).read()
 
     def delete(self, block):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"delete_element"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (block), "taskname": taskname}))).read()
 
     def switch_initial(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"switch_initial"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"switch_initial"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def auto_sanitize(self, auto):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"auto_sanitize"', "username": username}))).read()
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": "true" if auto else "false", "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"auto_sanitize"', "taskname": taskname}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": "true" if auto else "false", "taskname": taskname}))).read()
 
     def set_current(self, name):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % (name), "taskname": taskname}))).read()
 
     def poll(self):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"poll"', "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"poll"', "taskname": taskname}))).read()
 
 def lower(value):
     return value / JUMP * JUMP

interface/HUTN/hutn_compiler/constructors_object_visitor.py

@@ -14,7 +14,7 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
     def __init__(self, args):
         ConstructorsVisitor.__init__(self, args)
 
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -27,8 +27,8 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
             md5.update(f.read())
         self.hash_file = md5.hexdigest()
 
-        # Create user
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.username, "username": "user_manager"}))).read()
+        # Create task
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.taskname, "taskname": "task_manager"}))).read()
 
         simple_filename = self.real_file.rsplit("/")[-1]
         print("[COMPILE] %s" % simple_filename)
@@ -38,7 +38,7 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
 
         def flush_data(data):
             if data:
-                urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username})), timeout=timeout).read()
+                urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname})), timeout=timeout).read()
             return []
 
         # Set up interface
@@ -52,11 +52,11 @@ class ConstructorsObjectVisitor(ConstructorsVisitor):
         # Finish the symbol table
         data.append(False)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
 
         # Wait for kernel to signal that it finished
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '2', "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '2', "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/hutn_compiler/linker.py

@@ -5,17 +5,17 @@ import json
 
 sys.path.append("scripts")
 
-def link(address, username, objects):
+def link(address, taskname, objects):
     # Read out all symbol tables that are to be linked
     definers = {}
-    users = {}
+    tasks = {}
     def flush_data(data):
         if data:
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username})), timeout=10).read()
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=10).read()
         return []
     flush_data([3, "link_and_load"] + objects + ["", "main"])
 
-    v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+    v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
     v = json.loads(v)
     if "OK" not in v:
         print(v)
@@ -23,13 +23,13 @@ def link(address, username, objects):
 
 if __name__ == "__main__":
     if len(sys.argv) == 1:
-        print("No username defined")
+        print("No taskname defined")
     else:
         address = sys.argv[1]
-        username = sys.argv[2]
+        taskname = sys.argv[2]
         objects = set(sys.argv[3:])
 
         if objects:
-            link(address, username, objects)
+            link(address, taskname, objects)
         else:
             print("No files to link defined")

interface/HUTN/hutn_compiler/model_object_visitor.py

@@ -11,7 +11,7 @@ def empty(s):
 class ModelObjectVisitor(ModelVisitor):
     def __init__(self, args):
         ModelVisitor.__init__(self, args)
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -23,8 +23,8 @@ class ModelObjectVisitor(ModelVisitor):
         # Wait for kernel to signal that it finished
         data.append(2)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/hutn_compiler/primitives_object_visitor.py

@@ -10,7 +10,7 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
     def __init__(self, args):
         PrimitivesVisitor.__init__(self, args)
 
-        self.username = args[0]
+        self.taskname = args[0]
         self.obj_file = args[1]
         self.real_file = args[2]
         self.address = args[3]
@@ -23,8 +23,8 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
             md5.update(f.read())
         self.hash_file = md5.hexdigest()
 
-        # Create user
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.username, "username": "user_manager"}))).read()
+        # Create task
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "value": '"%s"' % self.taskname, "taskname": "task_manager"}))).read()
 
         simple_filename = self.real_file.rsplit("/")[-1]
         print("[COMPILE] %s" % simple_filename)
@@ -49,8 +49,8 @@ class PrimitivesObjectVisitor(PrimitivesVisitor):
         # Wait for kernel to signal that it finished
         data.append(2)
 
-        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": self.username}))).read()
-        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "username": self.username}))).read()
+        urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": self.taskname}))).read()
+        v = urllib2.urlopen(urllib2.Request(self.address, urllib.urlencode({"op": "get_output", "taskname": self.taskname}))).read()
         v = json.loads(v)
         if v == "DONE":
             return True

interface/HUTN/includes/primitives.alh

@@ -81,7 +81,7 @@ Boolean function string_startswith(a: String, b: String)
 Element function deserialize(a: String) 
 String function log(a: String)
 Element function read_root()
-Element function read_userroot()
+Element function read_taskroot()
 Element function input()
 Element function output(a : Element)
 Boolean function is_physical_int(a : Element)

interface/HUTN/includes/task_interface.alh

@@ -0,0 +1 @@
+Void function new_task()

interface/HUTN/includes/task_manager.alh

@@ -0,0 +1 @@
+Void function task_management()

interface/HUTN/includes/user_interface.alh

@@ -1 +0,0 @@
-Void function new_user()

interface/HUTN/includes/user_manager.alh

@@ -1 +0,0 @@
-Void function user_management()

kernel/modelverse_jit/intrinsics.py

@@ -242,12 +242,12 @@ MISC_INTRINSICS = {
             tree_ir.LoadLocalInstruction(jit.KWARGS_PARAMETER_NAME),
             tree_ir.LiteralInstruction('root')),
 
-    # read_userroot
-    'read_userroot' :
+    # read_taskroot
+    'read_taskroot' :
         lambda:
         tree_ir.LoadIndexInstruction(
             tree_ir.LoadLocalInstruction(jit.KWARGS_PARAMETER_NAME),
-            tree_ir.LiteralInstruction('user_root')),
+            tree_ir.LiteralInstruction('task_root')),
 
     # Dictionary operations
     'dict_read' :

kernel/modelverse_jit/jit.py

@@ -20,7 +20,7 @@ LOCALS_NODE_NAME = "jit_locals"
 """The name of the node that is connected to all JIT locals in a given function call."""
 
 LOCALS_EDGE_NAME = "jit_locals_edge"
-"""The name of the edge that connects the LOCALS_NODE_NAME node to a user root."""
+"""The name of the edge that connects the LOCALS_NODE_NAME node to a task root."""
 
 def get_parameter_names(compiled_function):
     """Gets the given compiled function's parameter names."""
@@ -282,7 +282,7 @@ class ModelverseJit(object):
 
         raise primitive_functions.PrimitiveFinished(self.jitted_parameters[body_id])
 
-    def jit_compile(self, user_root, body_id, suggested_name=None):
+    def jit_compile(self, task_root, body_id, suggested_name=None):
         """Tries to jit the function defined by the given entry point id and parameter list."""
         # The comment below makes pylint shut up about our (hopefully benign) use of exec here.
         # pylint: disable=I0011,W0122
@@ -341,7 +341,7 @@ class ModelverseJit(object):
             raise JitCompilationFailedException(
                 "Function was marked '%s'." % jit_runtime.MUTABLE_FUNCTION_KEY)
         state = AnalysisState(
-            self, body_id, user_root, body_param_dict,
+            self, body_id, task_root, body_param_dict,
             self.max_instructions)
         constructed_body, = yield [("CALL_ARGS", [state.analyze, (body_id,)])]
         yield [("END_TRY", [])]
@@ -349,13 +349,13 @@ class ModelverseJit(object):
 
         # Write a prologue and prepend it to the generated function body.
         prologue_statements = []
-        # Create a LOCALS_NODE_NAME node, and connect it to the user root.
+        # Create a LOCALS_NODE_NAME node, and connect it to the task root.
         prologue_statements.append(
             tree_ir.create_new_local_node(
                 LOCALS_NODE_NAME,
                 tree_ir.LoadIndexInstruction(
                     tree_ir.LoadLocalInstruction(KWARGS_PARAMETER_NAME),
-                    tree_ir.LiteralInstruction('user_root')),
+                    tree_ir.LiteralInstruction('task_root')),
                 LOCALS_EDGE_NAME))
         for (key, val) in param_dict.items():
             arg_ptr = tree_ir.create_new_local_node(
@@ -399,13 +399,13 @@ class ModelverseJit(object):
 
 class AnalysisState(object):
     """The state of a bytecode analysis call graph."""
-    def __init__(self, jit, body_id, user_root, local_mapping, max_instructions=None):
+    def __init__(self, jit, body_id, task_root, local_mapping, max_instructions=None):
         self.analyzed_instructions = set()
         self.function_vars = set()
         self.local_vars = set()
         self.body_id = body_id
         self.max_instructions = max_instructions
-        self.user_root = user_root
+        self.task_root = task_root
         self.jit = jit
         self.local_mapping = local_mapping
         self.function_name = jit.jitted_entry_points[body_id]
@@ -431,14 +431,14 @@ class AnalysisState(object):
                 "Local is used as target of function call.")
         self.function_vars.add(local_id)
 
-    def retrieve_user_root(self):
-        """Creates an instruction that stores the user_root variable
+    def retrieve_task_root(self):
+        """Creates an instruction that stores the task_root variable
            in a local."""
         return tree_ir.StoreLocalInstruction(
-            'user_root',
+            'task_root',
             tree_ir.LoadIndexInstruction(
                 tree_ir.LoadLocalInstruction(KWARGS_PARAMETER_NAME),
-                tree_ir.LiteralInstruction('user_root')))
+                tree_ir.LiteralInstruction('task_root')))
 
     def load_kernel(self):
         """Creates an instruction that loads the Modelverse kernel."""
@@ -583,14 +583,14 @@ class AnalysisState(object):
         #
         # value = <some tree>
         # last_output, last_output_link, new_last_output = \
-        #                 yield [("RD", [user_root, "last_output"]),
-        #                        ("RDE", [user_root, "last_output"]),
+        #                 yield [("RD", [task_root, "last_output"]),
+        #                        ("RDE", [task_root, "last_output"]),
         #                        ("CN", []),
         #                       ]
         # _, _, _, _ = \
         #                 yield [("CD", [last_output, "value", value]),
         #                        ("CD", [last_output, "next", new_last_output]),
-        #                        ("CD", [user_root, "last_output", new_last_output]),
+        #                        ("CD", [task_root, "last_output", new_last_output]),
         #                        ("DE", [last_output_link])
         #                       ]
         # yield None
@@ -599,17 +599,17 @@ class AnalysisState(object):
         value_val, = yield [("CALL_ARGS", [self.analyze, (value_id,)])]
         value_local = tree_ir.StoreLocalInstruction('value', value_val)
 
-        store_user_root = self.retrieve_user_root()
+        store_task_root = self.retrieve_task_root()
         last_output = tree_ir.StoreLocalInstruction(
             'last_output',
             tree_ir.ReadDictionaryValueInstruction(
-                store_user_root.create_load(),
+                store_task_root.create_load(),
                 tree_ir.LiteralInstruction('last_output')))
 
         last_output_link = tree_ir.StoreLocalInstruction(
             'last_output_link',
             tree_ir.ReadDictionaryEdgeInstruction(
-                store_user_root.create_load(),
+                store_task_root.create_load(),
                 tree_ir.LiteralInstruction('last_output')))
 
         new_last_output = tree_ir.StoreLocalInstruction(
@@ -618,7 +618,7 @@ class AnalysisState(object):
 
         result = tree_ir.create_block(
             value_local,
-            store_user_root,
+            store_task_root,
             last_output,
             last_output_link,
             new_last_output,
@@ -631,7 +631,7 @@ class AnalysisState(object):
                 tree_ir.LiteralInstruction('next'),
                 new_last_output.create_load()),
             tree_ir.CreateDictionaryEdgeInstruction(
-                store_user_root.create_load(),
+                store_task_root.create_load(),
                 tree_ir.LiteralInstruction('last_output'),
                 new_last_output.create_load()),
             tree_ir.DeleteEdgeInstruction(last_output_link.create_load()),
@@ -654,7 +654,7 @@ class AnalysisState(object):
         #
         #     value = None
         #     while True:
-        #         _input = yield [("RD", [user_root, "input"])]
+        #         _input = yield [("RD", [task_root, "input"])]
         #         value = yield [("RD", [_input, "value"])]
         #
         #         if value is None:
@@ -664,15 +664,15 @@ class AnalysisState(object):
         #             break
         #
         #     _next = yield [("RD", [_input, "next"])]
-        #     yield [("CD", [user_root, "input", _next])]
+        #     yield [("CD", [task_root, "input", _next])]
         #     yield [("CE", [jit_locals, value])]
         #     yield [("DN", [_input])]
 
-        user_root = self.retrieve_user_root()
+        task_root = self.retrieve_task_root()
         _input = tree_ir.StoreLocalInstruction(
             None,
             tree_ir.ReadDictionaryValueInstruction(
-                user_root.create_load(),
+                task_root.create_load(),
                 tree_ir.LiteralInstruction('input')))
 
         value = tree_ir.StoreLocalInstruction(
@@ -684,7 +684,7 @@ class AnalysisState(object):
         raise primitive_functions.PrimitiveFinished(
             tree_ir.CompoundInstruction(
                 tree_ir.create_block(
-                    user_root,
+                    task_root,
                     value.create_store(tree_ir.LiteralInstruction(None)),
                     tree_ir.LoopInstruction(
                         tree_ir.create_block(
@@ -703,7 +703,7 @@ class AnalysisState(object):
                                     tree_ir.NopInstruction()),
                                 tree_ir.BreakInstruction()))),
                     tree_ir.CreateDictionaryEdgeInstruction(
-                        user_root.create_load(),
+                        task_root.create_load(),
                         tree_ir.LiteralInstruction('input'),
                         tree_ir.ReadDictionaryValueInstruction(
                             _input.create_load(),
@@ -725,7 +725,7 @@ class AnalysisState(object):
         #     if 'local_var' in locals():
         #         tmp = local_var
         #     else:
-        #         _globals, = yield [("RD", [user_root, "globals"])]
+        #         _globals, = yield [("RD", [task_root, "globals"])]
         #         global_var, = yield [("RD", [_globals, var_name])]
         #
         #         if global_var is None:
@@ -739,12 +739,12 @@ class AnalysisState(object):
             raise primitive_functions.PrimitiveFinished(
                 tree_ir.LoadLocalInstruction(name))
 
-        user_root = self.retrieve_user_root()
+        task_root = self.retrieve_task_root()
         global_var = tree_ir.StoreLocalInstruction(
             'global_var',
             tree_ir.ReadDictionaryValueInstruction(
                 tree_ir.ReadDictionaryValueInstruction(
-                    user_root.create_load(),
+                    task_root.create_load(),
                     tree_ir.LiteralInstruction('globals')),
                 tree_ir.LiteralInstruction(var_name)))
 
@@ -767,7 +767,7 @@ class AnalysisState(object):
                 tree_ir.LoadLocalInstruction(name),
                 tree_ir.CompoundInstruction(
                     tree_ir.create_block(
-                        user_root,
+                        task_root,
                         global_var,
                         err_block),
                     global_var.create_load())))
@@ -802,7 +802,7 @@ class AnalysisState(object):
         # To resolve a variable, we'll do something along the
         # lines of:
         #
-        #     _globals, = yield [("RD", [user_root, "globals"])]
+        #     _globals, = yield [("RD", [task_root, "globals"])]
         #     global_var = yield [("RD", [_globals, var_name])]
         #
         #     if global_var is None:
@@ -811,11 +811,11 @@ class AnalysisState(object):
         #
         #     tmp = global_var
 
-        user_root = self.retrieve_user_root()
+        task_root = self.retrieve_task_root()
         _globals = tree_ir.StoreLocalInstruction(
             '_globals',
             tree_ir.ReadDictionaryValueInstruction(
-                user_root.create_load(),
+                task_root.create_load(),
                 tree_ir.LiteralInstruction('globals')))
 
         global_var = tree_ir.StoreLocalInstruction(
@@ -827,7 +827,7 @@ class AnalysisState(object):
         raise primitive_functions.PrimitiveFinished(
             tree_ir.CompoundInstruction(
                 tree_ir.create_block(
-                    user_root,
+                    task_root,
                     _globals,
                     global_var,
                     tree_ir.SelectInstruction(
@@ -911,7 +911,7 @@ class AnalysisState(object):
             compiled_func = self.jit.lookup_compiled_function(callee_name)
             if compiled_func is None:
                 # Compile the callee.
-                yield [("CALL_ARGS", [self.jit.jit_compile, (self.user_root, body_id, callee_name)])]
+                yield [("CALL_ARGS", [self.jit.jit_compile, (self.task_root, body_id, callee_name)])]
             else:
                 self.jit.register_compiled(body_id, compiled_func, callee_name)
 
@@ -989,7 +989,7 @@ class AnalysisState(object):
                 resolved_var_name, = yield [("RV", [resolved_var_id])]
 
                 # Try to look up the name as a global.
-                _globals, = yield [("RD", [self.user_root, "globals"])]
+                _globals, = yield [("RD", [self.task_root, "globals"])]
                 global_var, = yield [("RD", [_globals, resolved_var_name])]
                 global_val, = yield [("RD", [global_var, "value"])]
 

kernel/modelverse_jit/runtime.py

@@ -12,7 +12,7 @@ FUNCTION_BODY_KEY = "body"
 
 def call_function(function_id, named_arguments, **kwargs):
     """Runs the function with the given id, passing it the specified argument dictionary."""
-    user_root = kwargs['user_root']
+    task_root = kwargs['task_root']
     kernel = kwargs['mvk']
     body_id, is_mutable = yield [
         ("RD", [function_id, FUNCTION_BODY_KEY]),
@@ -35,7 +35,7 @@ def call_function(function_id, named_arguments, **kwargs):
     yield [("TRY", [])]
     yield [("CATCH", [JitCompilationFailedException, handle_jit_failed])]
     # Try to compile.
-    compiled_func, = yield [("CALL_ARGS", [kernel.jit_compile, (user_root, body_id)])]
+    compiled_func, = yield [("CALL_ARGS", [kernel.jit_compile, (task_root, body_id)])]
     yield [("END_TRY", [])]
     # Add the keyword arguments to the argument dictionary.
     named_arguments.update(kwargs)
@@ -45,16 +45,16 @@ def call_function(function_id, named_arguments, **kwargs):
 def interpret_function(function_id, named_arguments, **kwargs):
     """Makes the interpreter run the function with the given id for the specified
        argument dictionary."""
-    user_root = kwargs['user_root']
+    task_root = kwargs['task_root']
     kernel = kwargs['mvk']
-    user_frame, = yield [("RD", [user_root, "frame"])]
-    inst, body_id = yield [("RD", [user_frame, "IP"]), ("RD", [function_id, FUNCTION_BODY_KEY])]
+    task_frame, = yield [("RD", [task_root, "frame"])]
+    inst, body_id = yield [("RD", [task_frame, "IP"]), ("RD", [function_id, FUNCTION_BODY_KEY])]
     kernel.jit.mark_entry_point(body_id)
 
     # Create a new stack frame.
     frame_link, new_phase, new_frame, new_evalstack, new_symbols, \
         new_returnvalue, intrinsic_return = \
-                    yield [("RDE", [user_root, "frame"]),
+                    yield [("RDE", [task_root, "frame"]),
                            ("CNV", ["init"]),
                            ("CN", []),
                            ("CN", []),
@@ -64,14 +64,14 @@ def interpret_function(function_id, named_arguments, **kwargs):
                           ]
 
     _, _, _, _, _, _, _, _, _, _ = \
-                    yield [("CD", [user_root, "frame", new_frame]),
+                    yield [("CD", [task_root, "frame", new_frame]),
                            ("CD", [new_frame, "evalstack", new_evalstack]),
                            ("CD", [new_frame, "symbols", new_symbols]),
                            ("CD", [new_frame, "returnvalue", new_returnvalue]),
                            ("CD", [new_frame, "caller", inst]),
                            ("CD", [new_frame, "phase", new_phase]),
                            ("CD", [new_frame, "IP", body_id]),
-                           ("CD", [new_frame, "prev", user_frame]),
+                           ("CD", [new_frame, "prev", task_frame]),
                            ("CD", [
                                new_frame,
                                primitive_functions.EXCEPTION_RETURN_KEY,
@@ -91,7 +91,7 @@ def interpret_function(function_id, named_arguments, **kwargs):
         symbol_edge, = yield [("CE", [new_symbols, variable])]
         yield [("CE", [symbol_edge, param_var])]
 
-    username = kwargs['username']
+    taskname = kwargs['taskname']
     def exception_handler(ex):
         # print('Returning from interpreted function. Result: %s' % ex.result)
         raise primitive_functions.PrimitiveFinished(ex.result)
@@ -100,16 +100,16 @@ def interpret_function(function_id, named_arguments, **kwargs):
     yield [("TRY", [])]
     yield [("CATCH", [primitive_functions.InterpretedFunctionFinished, exception_handler])]
     while 1:
-        result, = yield [("CALL_ARGS", [kernel.execute_rule, (username,)])]
+        result, = yield [("CALL_ARGS", [kernel.execute_rule, (taskname,)])]
         # An instruction has completed. Forward it.
         yield result
 
 def get_input(**parameters):
     """Retrieves input."""
     mvk = parameters["mvk"]
-    user_root = parameters["user_root"]
+    task_root = parameters["task_root"]
     while 1:
-        yield [("CALL_ARGS", [mvk.input_init, (user_root,)])]
+        yield [("CALL_ARGS", [mvk.input_init, (task_root,)])]
         # Finished
         if mvk.success:
             # Got some input, so we can access it

kernel/modelverse_kernel/compiled.py

@@ -452,4 +452,4 @@ def retype(a, b, c, **remainder):
         yield [("DE", [prev_edge])]
     t, =        yield [("CE", [tm, mm_ref])]
     yield [("CE", [t, m_ref])]
-    raise PrimitiveFinished(None)
+    raise PrimitiveFinished(None)

kernel/modelverse_kernel/primitives.py

@@ -558,8 +558,8 @@ def log(a, **remainder):
     print("== LOG == " + str(a_value))
     raise PrimitiveFinished(a)
 
-def read_userroot(user_root, **remainder):
-    raise PrimitiveFinished(user_root)
+def read_taskroot(task_root, **remainder):
+    raise PrimitiveFinished(task_root)
 
 def time(**remainder):
     import time

kernel/mvk_server/classes/executor.xml

@@ -65,22 +65,22 @@
                 <state id="queue">
                     <transition event="execute" target=".">
                         <parameter name="returnpath"/>
-                        <parameter name="username"/>
+                        <parameter name="taskname"/>
                         <parameter name="operation"/>
                         <parameter name="params"/>
                         <parameter name="request_id"/>
                         <script>
-                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, username, operation, params, request_id, True))
+                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, taskname, operation, params, request_id, True))
                         </script>
                     </transition>
                     <transition event="execute_debug" target=".">
                         <parameter name="returnpath"/>
-                        <parameter name="username"/>
+                        <parameter name="taskname"/>
                         <parameter name="operation"/>
                         <parameter name="params"/>
                         <parameter name="request_id"/>
                         <script>
-                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, username, operation, params, request_id, False))
+                            self.request_queue.append((("/" + returnpath) if returnpath is not None else None, taskname, operation, params, request_id, False))
                         </script>
                     </transition>
                 </state>
@@ -98,11 +98,11 @@
                             self.mvk.success = True
                             self.first = True
 
-                            self.returnpath, username, operation, params, self.request_id, self.mvk.allow_compiled = self.request_queue.pop(0)
+                            self.returnpath, taskname, operation, params, self.request_id, self.mvk.allow_compiled = self.request_queue.pop(0)
                             reply = None
                             commands = []
                             while 1:
-                                commands = self.mvk.execute_yields(username, operation, params, reply)
+                                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]

kernel/mvk_server/classes/mvkcontroller.xml

@@ -2,17 +2,17 @@
     <relationships>
         <association name="to_mvs" class="HTTPClient" min="1" max="1"/>
         <association name="to_mvi" class="Server" min="1" max="1"/>
-        <association name="users" class="UserStatechart"/>
+        <association name="tasks" class="UserStatechart"/>
         <association name="executor" class="Executor" min="1" max="1"/>
     </relationships>
     <constructor>
         <parameter name="params"/>
         <body>
             <![CDATA[
-            self.users = []
-            self.user_statecharts = {"__hierarchy": None}
+            self.tasks = []
+            self.task_statecharts = {"__hierarchy": None}
             self.input_queue = []
-            self.user_queue = {}
+            self.task_queue = {}
             self.source = None
             self.root = None
 
@@ -101,12 +101,12 @@
                                     else:
                                         value = json.loads(data["data"])
                                     for v in value[:-1]:
-                                        self.input_queue.append((None, data["op"], [v], data["username"]))
-                                    self.input_queue.append((source, data["op"], [value[-1]], data["username"]))
+                                        self.input_queue.append((None, data["op"], [v], data["taskname"]))
+                                    self.input_queue.append((source, data["op"], [value[-1]], data["taskname"]))
                                     print("Added to input queue")
                                 else:
                                     print("Appending " + data["op"])
-                                    self.input_queue.append((source, data["op"], args, data["username"]))
+                                    self.input_queue.append((source, data["op"], args, data["taskname"]))
                             except ValueError:
                                 print("Error when deserializing request: " + str(data))
                                 raise
@@ -117,16 +117,16 @@
 
             <state id="push" initial="wait">
                 <state id="wait">
-                    <transition cond="self.input_queue and self.input_queue[0][3] in self.user_statecharts" target="../process"/>
+                    <transition cond="self.input_queue and self.input_queue[0][3] in self.task_statecharts" target="../process"/>
                     <!-- User is not yet detected, so stall this message -->
-                    <transition cond="self.input_queue and self.input_queue[0][3] not in self.user_statecharts" target=".">
-                        <!-- Move it to the back of the list, so we can process other users first -->
+                    <transition cond="self.input_queue and self.input_queue[0][3] not in self.task_statecharts" target=".">
+                        <!-- Move it to the back of the list, so we can process other tasks first -->
                         <script>
-                            print("Queue user")
-                            self.user_queue.setdefault(self.input_queue[0][3], []).append(self.input_queue.pop(0))
+                            print("Queue task")
+                            self.task_queue.setdefault(self.input_queue[0][3], []).append(self.input_queue.pop(0))
                         </script>
                         <!-- Force a refresh too -->
-                        <raise event="force_user_refresh"/>
+                        <raise event="force_task_refresh"/>
                     </transition>
 
                 </state>
@@ -134,9 +134,9 @@
                 <state id="process">
                     <transition cond="self.input_queue[0][1] == 'set_input'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="set_input" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="set_input" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -144,9 +144,9 @@
 
                     <transition cond="self.input_queue[0][1] == 'get_output'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="get_output" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="get_output" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -155,9 +155,9 @@
                     <transition cond="self.input_queue[0][1] == 'pause'" target="../wait">
                         <script>
                             print("Sending pause")
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="pause" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="pause" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -165,9 +165,9 @@
                     
                     <transition cond="self.input_queue[0][1] == 'resume'" target="../wait">
                         <script>
-                            source, op, args, username = self.input_queue.pop(0)
+                            source, op, args, taskname = self.input_queue.pop(0)
                         </script>
-                        <raise event="resume" scope="narrow" target="self.user_statecharts[username]">
+                        <raise event="resume" scope="narrow" target="self.task_statecharts[taskname]">
                             <parameter expr="source"/>
                             <parameter expr="args"/>
                         </raise>
@@ -175,7 +175,7 @@
                 </state>
             </state>
 
-            <state id="find_users" initial="get_all_links">
+            <state id="find_tasks" initial="get_all_links">
                 <state id="get_all_links">
                     <onentry>
                         <raise event="raw_exec" scope="narrow" target="'executor'">
@@ -184,54 +184,54 @@
                         </raise>
                     </onentry>
 
-                    <transition event="raw_exec_reply" target="../retrieve_users">
+                    <transition event="raw_exec_reply" target="../retrieve_tasks">
                         <parameter name="data"/>
                         <script>
-                            self.users = data[0][0]
+                            self.tasks = data[0][0]
                         </script>
                     </transition>
                 </state>
 
-                <state id="retrieve_users">
-                    <transition cond="self.users" target="../got_usernames">
+                <state id="retrieve_tasks">
+                    <transition cond="self.tasks" target="../got_tasknames">
                         <raise event="raw_exec" scope="narrow" target="'executor'">
-                            <parameter expr="[['RV', [user]] for user in self.users]"/>
+                            <parameter expr="[['RV', [task]] for task in self.tasks]"/>
                             <parameter expr="'parent'"/>
                         </raise>
                     </transition>
-                    <transition cond="not self.users" target="../wait"/>
+                    <transition cond="not self.tasks" target="../wait"/>
                 </state>
 
-                <state id="got_usernames">
-                    <transition event="raw_exec_reply" target="../process_users">
+                <state id="got_tasknames">
+                    <transition event="raw_exec_reply" target="../process_tasks">
                         <parameter name="data"/>
                         <script>
                             data = set([v[0] for v in data])
-                            self.add_users = [v for v in data if v not in self.user_statecharts]
-                            self.delete_users = [v for v in self.user_statecharts if v not in data]
+                            self.add_tasks = [v for v in data if v not in self.task_statecharts]
+                            self.delete_tasks = [v for v in self.task_statecharts if v not in data]
                         </script>
                     </transition>
                 </state>
 
-                <state id="process_users">
-                    <transition cond="not self.add_users and not self.delete_users" target="../wait"/>
-                    <transition cond="self.add_users and not self.delete_users" target="../creating_user">
+                <state id="process_tasks">
+                    <transition cond="not self.add_tasks and not self.delete_tasks" target="../wait"/>
+                    <transition cond="self.add_tasks and not self.delete_tasks" target="../creating_task">
                         <raise event="create_instance" scope="cd">
-                            <parameter expr="'users'"/>
+                            <parameter expr="'tasks'"/>
                             <parameter expr="'UserStatechart'"/>
-                            <parameter expr="self.add_users[0]"/>
+                            <parameter expr="self.add_tasks[0]"/>
                             <parameter expr="self.mvk"/>
                         </raise>
                     </transition>
-                    <transition cond="self.delete_users" target=".">
+                    <transition cond="self.delete_tasks" target=".">
                         <raise event="delete_instance" scope="cd">
-                            <parameter expr="self.user_statecharts.pop(self.delete_users.pop(0))"/>
+                            <parameter expr="self.task_statecharts.pop(self.delete_tasks.pop(0))"/>
                         </raise>
                     </transition>
                 </state>
 
-                <state id="creating_user">
-                    <transition event="instance_created" target="../retrieve_users">
+                <state id="creating_task">
+                    <transition event="instance_created" target="../retrieve_tasks">
                         <parameter name="instancename"/>
                         <raise scope="cd" event="start_instance">
                             <parameter expr="instancename"/>
@@ -240,17 +240,17 @@
                             <parameter expr="instancename"/>
                         </raise>
                         <script>
-                            self.user_statecharts[self.add_users[0]] = instancename
-                            # Repush all this user's messages in the input queue
-                            self.input_queue.extend(self.user_queue.pop(self.add_users[0], []))
-                            self.add_users.pop(0)
+                            self.task_statecharts[self.add_tasks[0]] = instancename
+                            # Repush all this task's messages in the input queue
+                            self.input_queue.extend(self.task_queue.pop(self.add_tasks[0], []))
+                            self.add_tasks.pop(0)
                         </script>
                     </transition>
                 </state>
 
                 <state id="wait">
                     <transition after="1.0" target="../get_all_links"/>
-                    <transition event="force_user_refresh" target="../get_all_links"/>
+                    <transition event="force_task_refresh" target="../get_all_links"/>
                 </state>
             </state>
         </parallel>

kernel/mvk_server/classes/user_statechart.xml

@@ -3,11 +3,11 @@
         <association name="parent" class="MvKController" min="1" max="1"/>
     </relationships>
     <constructor>
-        <parameter name="username"/>
+        <parameter name="taskname"/>
         <parameter name="mvk" />
         <body>
             <![CDATA[
-            self.username = username
+            self.taskname = taskname
             self.mvk = mvk
 
             self.output_queue = []
@@ -37,7 +37,7 @@
                         <onentry>
                             <raise event="execute" scope="narrow" target="'parent/executor'">
                                 <parameter expr="self.returnpath"/>
-                                <parameter expr="self.username"/>
+                                <parameter expr="self.taskname"/>
                                 <parameter expr="'execute_rule'"/>
                                 <parameter expr="[]"/>
                                 <parameter expr="self.request_id"/>
@@ -68,7 +68,7 @@
                         <parameter name="source"/>
                         <parameter name="args"/>
                         <raise event="HTTP_input" scope="narrow" target="'parent/to_mvi/' + source">
-                            <parameter expr="json.dumps({'user': self.username, 'state': 'paused', 'info': self.mvk.debug_info[self.username]})"/>
+                            <parameter expr="json.dumps({'task': self.taskname, 'state': 'paused', 'info': self.mvk.debug_info[self.taskname]})"/>
                         </raise>
                     </transition>
                 </state>
@@ -77,7 +77,7 @@
                         <parameter name="source"/>
                         <parameter name="args"/>
                         <raise event="HTTP_input" scope="narrow" target="'parent/to_mvi/' + source">
-                            <parameter expr="json.dumps({'user': self.username, 'state': 'running'})"/>
+                            <parameter expr="json.dumps({'task': self.taskname, 'state': 'running'})"/>
                         </raise>
                     </transition>
                 </state>
@@ -90,7 +90,7 @@
                         <parameter name="args"/>
                         <raise event="execute" scope="narrow" target="'parent/executor'">
                             <parameter expr="self.returnpath"/>
-                            <parameter expr="self.username"/>
+                            <parameter expr="self.taskname"/>
                             <parameter expr="'set_input'"/>
                             <parameter expr="args"/>
                             <parameter expr="self.request_id"/>
@@ -133,7 +133,7 @@
                     <transition cond="self.outstanding_output is None and self.output_queue" target=".">
                         <raise event="execute" scope="narrow" target="'parent/executor'">
                             <parameter expr="self.returnpath"/>
-                            <parameter expr="self.username"/>
+                            <parameter expr="self.taskname"/>
                             <parameter expr="'get_output'"/>
                             <parameter expr="[]"/>
                             <parameter expr="self.request_id"/>

kernel/mvk_server/server.xml

@@ -22,6 +22,6 @@
     <class src="classes/server.xml"/>
     <class src="classes/socket.xml"/>
     <class src="classes/http_client.xml"/>
-    <class src="classes/user_statechart.xml"/>
+    <class src="classes/task_statechart.xml"/>
     <class src="classes/executor.xml"/>
 </diagram>

kernel/test/functions/factorial.eps

@@ -167,12 +167,12 @@ def
 % /arrowwidth 5 def
 
 % make sure pdfmark is harmless for PS-interpreters other than Distiller
-/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+/pdfmark where {pop} {taskdict /pdfmark /cleartomark load put} ifelse
 % make '<<' and '>>' safe on PS Level 1 devices
 /languagelevel where {pop languagelevel}{1} ifelse
 2 lt {
-    userdict (<<) cvn ([) cvn load put
-    userdict (>>) cvn ([) cvn load put
+    taskdict (<<) cvn ([) cvn load put
+    taskdict (>>) cvn ([) cvn load put
 } if
 
 %%EndSetup

kernel/test/functions/fib_naive.eps

@@ -167,12 +167,12 @@ def
 % /arrowwidth 5 def
 
 % make sure pdfmark is harmless for PS-interpreters other than Distiller
-/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
+/pdfmark where {pop} {taskdict /pdfmark /cleartomark load put} ifelse
 % make '<<' and '>>' safe on PS Level 1 devices
 /languagelevel where {pop languagelevel}{1} ifelse
 2 lt {
-    userdict (<<) cvn ([) cvn load put
-    userdict (>>) cvn ([) cvn load put
+    taskdict (<<) cvn ([) cvn load put
+    taskdict (>>) cvn ([) cvn load put
 } if
 
 %%EndSetup

kernel/test/functions/test_factorial.py

@@ -1,6 +1,6 @@
 import unittest
 from modelverse_kernel.main import ModelverseKernel
-from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_inst_ref, add_new_user
+from utils import execute_until_finished, MvSWrapper, get_inst, get_phase, get_returnvalue, get_phase_ref, read_primitive_interfaces, get_inst_ref, add_new_task
 import math
 
 class TestFactorial(unittest.TestCase):
@@ -178,9 +178,9 @@ class TestFactorial(unittest.TestCase):
         self.mvs.execute("CD", [invoke_factorial, "next", const_5])
         self.mvs.execute("CD", [const_5, "node", value_c])
 
-        execute_until_finished(self.mvk, self.mvs, "initialize_new_user", [])
+        execute_until_finished(self.mvk, self.mvs, "initialize_new_task", [])
 
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "user_1"])[0], "globals"])[0] , var_value_4])[0]
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/test_fib_naive.py

@@ -213,10 +213,10 @@ class TestFibNaive(unittest.TestCase):
         self.mvs.execute("CD", [invoke_fib, "next", const_6])
         self.mvs.execute("CD", [const_6, "node", value_c])
 
-        execute_until_finished(self.mvk, self.mvs, "initialize_new_user", ["user_1"])
+        execute_until_finished(self.mvk, self.mvs, "initialize_new_task", ["task_1"])
 
-        # Define in globals for user, kind of a hack...
-        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "user_1"])[0], "globals"])[0] , var_value_4])[0]
+        # Define in globals for task, kind of a hack...
+        t = self.mvs.execute("CE", [self.mvs.execute("RD", [self.mvs.execute("RD", [root, "task_1"])[0], "globals"])[0] , var_value_4])[0]
         self.mvs.execute("CE", [t, var_4])
 
         ### Execute rules

kernel/test/functions/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/instructions/test_instruction_access.py

@@ -8,19 +8,19 @@ class Testaccess(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_access(self):
         """
@@ -35,7 +35,7 @@ class Testaccess(unittest.TestCase):
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
         self.mvs.execute("CD", [self.resolve, "var", self.var])
         self.mvs.execute("CD", [self.value, "value", self.const_a])

kernel/test/instructions/test_instruction_assign.py

@@ -8,19 +8,19 @@ class TestAssign(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_assign_simple(self):
         """
@@ -36,7 +36,7 @@ class TestAssign(unittest.TestCase):
         self.inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         self.resolve = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.resolve])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.resolve, "var", self.var])
@@ -79,7 +79,7 @@ class TestAssign(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
 
         # Check if the new value is really assigned
-        t = self.mvs.execute("RD", [self.root, "user_1"])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
         t = self.mvs.execute("RD", [t, "frame"])[0]
         t = self.mvs.execute("RD", [t, "symbols"])[0]
         t = self.mvs.execute("RDN", [t, self.var])[0]

kernel/test/instructions/test_instruction_break.py

@@ -8,19 +8,19 @@ class TestBreak(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_break(self):
         """
@@ -41,7 +41,7 @@ class TestBreak(unittest.TestCase):
         self.value_cond = self.mvs.execute("CNV", [True])[0]
         self.break_inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/instructions/test_instruction_call.py

@@ -8,19 +8,19 @@ class Testcall(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_no_params(self):
         """
@@ -44,7 +44,7 @@ class Testcall(unittest.TestCase):
         self.const_a = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.access, "var", self.resolve])
@@ -128,7 +128,7 @@ class Testcall(unittest.TestCase):
         self.value_abc = self.mvs.execute("CNV", ["abc"])[0]
         self.value_def = self.mvs.execute("CNV", ["def"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg])
@@ -237,7 +237,7 @@ class Testcall(unittest.TestCase):
         self.value_e = self.mvs.execute("CNV", ["e"])[0]
         self.value_f = self.mvs.execute("CNV", ["f"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])
@@ -369,7 +369,7 @@ class Testcall(unittest.TestCase):
         self.value_e = self.mvs.execute("CNV", ["e"])[0]
         self.value_f = self.mvs.execute("CNV", ["f"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "func", self.access])
         self.mvs.execute("CD", [self.inst, "next", self.const_a])
         self.mvs.execute("CD", [self.inst, "params", self.actual_arg_a])

kernel/test/instructions/test_instruction_continue.py

@@ -8,19 +8,19 @@ class Testcontinue(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_continue(self):
         """
@@ -41,7 +41,7 @@ class Testcontinue(unittest.TestCase):
         self.value_cond = self.mvs.execute("CNV", [True])[0]
         self.continue_inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/instructions/test_instruction_declare.py

@@ -8,27 +8,27 @@ class TestDeclare(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
         self.globals = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_root, "globals", self.globals])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_root, "globals", self.globals])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_declare(self):
         self.inst = self.mvs.execute("CNV", [{"value":"declare"}])[0]
         self.var = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
 
         ### Execute rules
@@ -41,11 +41,11 @@ class TestDeclare(unittest.TestCase):
         self.assertNotEquals(self.mvs.execute("RDN", [self.symbols, self.var])[0], None)
 
     def test_global(self):
-        self.global_symbols = self.mvs.execute("RD", [self.user_root, "globals"])[0]
+        self.global_symbols = self.mvs.execute("RD", [self.task_root, "globals"])[0]
         self.inst = self.mvs.execute("CNV", [{"value":"global"}])[0]
         self.var = self.mvs.execute("CNV", ["abc"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
 
         ### Execute rules

kernel/test/instructions/test_instruction_if.py

@@ -8,19 +8,19 @@ class Testif(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_if_true_with_else(self):
         """
@@ -43,7 +43,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "else", self.const_b])
@@ -109,7 +109,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_true])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])
@@ -177,7 +177,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_false = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "else", self.const_b])
@@ -243,7 +243,7 @@ class Testif(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_false = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_false])
         self.mvs.execute("CD", [self.inst, "then", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_c])

kernel/test/instructions/test_instruction_input.py

@@ -8,21 +8,21 @@ class TestInput(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
-        self.user_input = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
+        self.task_input = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_input(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -30,9 +30,9 @@ class TestInput(unittest.TestCase):
 
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
-        self.mvs.execute("CD", [self.user_input, "next", self.input_value])
-        self.mvs.execute("CD", [self.user_input, "value", self.value_a])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_input, "next", self.input_value])
+        self.mvs.execute("CD", [self.task_input, "value", self.value_a])
 
         ### Execute rules
         self.assertEquals(get_inst(self.root, self.mvs), "input")

kernel/test/instructions/test_instruction_output.py

@@ -8,25 +8,25 @@ class TestOutput(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
-        self.user_input = self.mvs.execute("CN", [])[0]
-        self.user_output = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
+        self.task_input = self.mvs.execute("CN", [])[0]
+        self.task_output = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "last_input", self.user_input])
-        self.mvs.execute("CD", [self.user_root, "output", self.user_output])
-        self.mvs.execute("CD", [self.user_root, "last_output", self.user_output])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "last_input", self.task_input])
+        self.mvs.execute("CD", [self.task_root, "output", self.task_output])
+        self.mvs.execute("CD", [self.task_root, "last_output", self.task_output])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_output_value(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -35,7 +35,7 @@ class TestOutput(unittest.TestCase):
         self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_a = self.mvs.execute("CNV", ["a"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value_a])
 
@@ -59,7 +59,7 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.user_output, "value"])[0]])[0], "a")
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [self.task_output, "value"])[0]])[0], "a")
 
     def test_output_node(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -68,7 +68,7 @@ class TestOutput(unittest.TestCase):
         self.const = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value])
 
@@ -92,7 +92,7 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.user_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)
 
     def test_output_edge(self):
         self.input_value = self.mvs.execute("CN", [])[0]
@@ -103,7 +103,7 @@ class TestOutput(unittest.TestCase):
         b = self.mvs.execute("CN", [])[0]
         self.value = self.mvs.execute("CE", [a,b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const])
         self.mvs.execute("CD", [self.const, "node", self.value])
 
@@ -127,4 +127,4 @@ class TestOutput(unittest.TestCase):
 
         self.assertEquals(get_inst(self.root, self.mvs), "output")
         self.assertEquals(get_phase(self.root, self.mvs), "finish")
-        self.assertEquals(self.mvs.execute("RD", [self.user_output, "value"])[0], self.value)
+        self.assertEquals(self.mvs.execute("RD", [self.task_output, "value"])[0], self.value)

kernel/test/instructions/test_instruction_resolve.py

@@ -8,21 +8,21 @@ class Testresolve(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.global_user = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.global_task = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_root, "globals", self.global_user])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_root, "globals", self.global_task])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_resolve_simple_local(self):
         """
@@ -33,7 +33,7 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
         t = self.mvs.execute("CE", [self.symbols, self.value])[0]
         self.mvs.execute("CE", [t, self.var])
@@ -56,9 +56,9 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_user, self.value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.value])[0]
         self.mvs.execute("CE", [t, self.var])
 
         ### Execute rules
@@ -80,9 +80,9 @@ class Testresolve(unittest.TestCase):
 
         self.inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "var", self.var])
-        t = self.mvs.execute("CE", [self.global_user, self.global_value])[0]
+        t = self.mvs.execute("CE", [self.global_task, self.global_value])[0]
         self.mvs.execute("CE", [t, self.var])
         t = self.mvs.execute("CE", [self.symbols, self.local_value])[0]
         self.mvs.execute("CE", [t, self.var])

kernel/test/instructions/test_instruction_return.py

@@ -8,44 +8,44 @@ class Testreturn(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_return(self):
         """
         Test the code:
             return True
         """
-        prev_user_frame = self.mvs.execute("CN", [])[0]
+        prev_task_frame = self.mvs.execute("CN", [])[0]
         prev_symbols = self.mvs.execute("CN", [])[0]
         prev_evalstack = self.mvs.execute("CN", [])[0]
         prev_returnvalue = self.mvs.execute("CN", [])[0]
         prev_phase = self.mvs.execute("CNV", ["init"])[0]
         prev_IP = self.mvs.execute("CNV", [{"value":"constant"}])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "prev", prev_user_frame])
-        self.mvs.execute("CD", [prev_user_frame, "symbols", prev_symbols])
-        self.mvs.execute("CD", [prev_user_frame, "evalstack", prev_evalstack])
-        self.mvs.execute("CD", [prev_user_frame, "phase", prev_phase])
-        self.mvs.execute("CD", [prev_user_frame, "IP", prev_IP])
-        self.mvs.execute("CD", [prev_user_frame, "returnvalue", prev_returnvalue])
+        self.mvs.execute("CD", [self.task_frame, "prev", prev_task_frame])
+        self.mvs.execute("CD", [prev_task_frame, "symbols", prev_symbols])
+        self.mvs.execute("CD", [prev_task_frame, "evalstack", prev_evalstack])
+        self.mvs.execute("CD", [prev_task_frame, "phase", prev_phase])
+        self.mvs.execute("CD", [prev_task_frame, "IP", prev_IP])
+        self.mvs.execute("CD", [prev_task_frame, "returnvalue", prev_returnvalue])
 
         self.inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         self.const_true = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.value_true = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "value", self.const_true])
         self.mvs.execute("CD", [self.const_true, "node", self.value_true])
 
@@ -71,6 +71,6 @@ class Testreturn(unittest.TestCase):
         self.assertEquals(get_phase(self.root, self.mvs), "init")
         self.assertEquals(get_returnvalue(self.root, self.mvs), True)
 
-        t = self.mvs.execute("RD", [self.root, "user_1"])[0]
+        t = self.mvs.execute("RD", [self.root, "task_1"])[0]
         t = self.mvs.execute("RD", [t, "frame"])[0]
-        self.assertEquals(t, prev_user_frame)
+        self.assertEquals(t, prev_task_frame)

kernel/test/instructions/test_instruction_while.py

@@ -8,19 +8,19 @@ class Testwhile(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
     def test_while_true(self):
         """
@@ -39,7 +39,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])
@@ -146,7 +146,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])
@@ -202,7 +202,7 @@ class Testwhile(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_cond = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.mvs.execute("CD", [self.inst, "cond", self.const_cond])
         self.mvs.execute("CD", [self.inst, "body", self.const_a])
         self.mvs.execute("CD", [self.inst, "next", self.const_b])

kernel/test/instructions/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/primitives/test_action.py

@@ -8,19 +8,19 @@ class TestAction(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -59,7 +59,7 @@ class TestAction(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -152,7 +152,7 @@ class TestAction(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_bool.py

@@ -8,19 +8,19 @@ class TestBool(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -95,7 +95,7 @@ class TestBool(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -188,7 +188,7 @@ class TestBool(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_cast.py

@@ -8,19 +8,19 @@ class TestCast(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -142,7 +142,7 @@ class TestCast(unittest.TestCase):
         else:
             self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_create.py

@@ -8,19 +8,19 @@ class TestCreate(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -76,7 +76,7 @@ class TestCreate(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -159,7 +159,7 @@ class TestCreate(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -222,7 +222,7 @@ class TestCreate(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_delete.py

@@ -8,19 +8,19 @@ class TestDelete(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -90,7 +90,7 @@ class TestDelete(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_dict.py

@@ -8,19 +8,19 @@ class TestDict(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -100,7 +100,7 @@ class TestDict(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -184,7 +184,7 @@ class TestDict(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -261,7 +261,7 @@ class TestDict(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_dict_special.py

@@ -8,19 +8,19 @@ class TestDictSpecials(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -106,7 +106,7 @@ class TestDictSpecials(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -193,7 +193,7 @@ class TestDictSpecials(unittest.TestCase):
 
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_edge.py

@@ -8,19 +8,19 @@ class TestEdge(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -52,7 +52,7 @@ class TestEdge(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_element.py

@@ -8,19 +8,19 @@ class TestType(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -77,7 +77,7 @@ class TestType(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_float.py

@@ -8,19 +8,19 @@ class TestInteger(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -92,7 +92,7 @@ class TestInteger(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -185,7 +185,7 @@ class TestInteger(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_integer.py

@@ -8,19 +8,19 @@ class TestInteger(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -92,7 +92,7 @@ class TestInteger(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -185,7 +185,7 @@ class TestInteger(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_list.py

@@ -8,19 +8,19 @@ class TestList(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -107,7 +107,7 @@ class TestList(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -192,7 +192,7 @@ class TestList(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -268,7 +268,7 @@ class TestList(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_read.py

@@ -8,19 +8,19 @@ class TestRead(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -205,7 +205,7 @@ class TestRead(unittest.TestCase):
         self.value_first = a
         self.value_second = b
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -287,7 +287,7 @@ class TestRead(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -350,7 +350,7 @@ class TestRead(unittest.TestCase):
         self.value_b = self.mvs.execute("CNV", ["b"])[0]
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_set.py

@@ -8,19 +8,19 @@ class TestSet(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -85,7 +85,7 @@ class TestSet(unittest.TestCase):
 
         self.construct(self.value_first, a)
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -170,7 +170,7 @@ class TestSet(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -246,7 +246,7 @@ class TestSet(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_set_node.py

@@ -8,19 +8,19 @@ class TestSetNode(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -93,7 +93,7 @@ class TestSetNode(unittest.TestCase):
 
         self.value_first = a
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/test_string.py

@@ -8,19 +8,19 @@ class TestString(unittest.TestCase):
         self.root = self.mvs.execute("RR", [])[0]
         self.mvk = ModelverseKernel(self.root)
 
-        self.user_root = self.mvs.execute("CN", [])[0]
-        self.user_frame = self.mvs.execute("CN", [])[0]
+        self.task_root = self.mvs.execute("CN", [])[0]
+        self.task_frame = self.mvs.execute("CN", [])[0]
         self.symbols = self.mvs.execute("CN", [])[0]
         self.evalstack = self.mvs.execute("CN", [])[0]
         self.returnvalue = self.mvs.execute("CN", [])[0]
         self.phase = self.mvs.execute("CNV", ["init"])[0]
 
-        self.mvs.execute("CD", [self.root, "user_1", self.user_root])
-        self.mvs.execute("CD", [self.user_root, "frame", self.user_frame])
-        self.mvs.execute("CD", [self.user_frame, "symbols", self.symbols])
-        self.mvs.execute("CD", [self.user_frame, "evalstack", self.evalstack])
-        self.mvs.execute("CD", [self.user_frame, "phase", self.phase])
-        self.mvs.execute("CD", [self.user_frame, "returnvalue", self.returnvalue])
+        self.mvs.execute("CD", [self.root, "task_1", self.task_root])
+        self.mvs.execute("CD", [self.task_root, "frame", self.task_frame])
+        self.mvs.execute("CD", [self.task_frame, "symbols", self.symbols])
+        self.mvs.execute("CD", [self.task_frame, "evalstack", self.evalstack])
+        self.mvs.execute("CD", [self.task_frame, "phase", self.phase])
+        self.mvs.execute("CD", [self.task_frame, "returnvalue", self.returnvalue])
 
         execute_until_finished(self.mvk, self.mvs, "load_primitives", [])
         self.primitives = read_primitive_interfaces(self.root, self.mvs)
@@ -104,7 +104,7 @@ class TestString(unittest.TestCase):
         self.value_first = self.mvs.execute("CNV", [a])[0]
         self.value_second = self.mvs.execute("CNV", [b])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -202,7 +202,7 @@ class TestString(unittest.TestCase):
         self.value_c = self.mvs.execute("CNV", ["c"])[0]
         self.value_first = self.mvs.execute("CNV", [a])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])
@@ -284,7 +284,7 @@ class TestString(unittest.TestCase):
         self.value_second = self.mvs.execute("CNV", [b])[0]
         self.value_third = self.mvs.execute("CNV", [c])[0]
 
-        self.mvs.execute("CD", [self.user_frame, "IP", self.inst])
+        self.mvs.execute("CD", [self.task_frame, "IP", self.inst])
         self.const_func = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         self.mvs.execute("CD", [self.inst, "func", self.const_func])
         self.mvs.execute("CD", [self.const_func, "node", self.primitives[operation]])

kernel/test/primitives/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/rules/test_rules_access.py

@@ -10,29 +10,29 @@ class Testaccess(unittest.TestCase):
 
     def test_access_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         var_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "var", var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,26 +40,26 @@ class Testaccess(unittest.TestCase):
 
     def test_access_eval(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["eval"])[0]
         inst = self.mvs.execute("CNV", [{"value":"access"}])[0]
         value = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [returnvalue, "value", value])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], value)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)

kernel/test/rules/test_rules_assign.py

@@ -10,29 +10,29 @@ class TestAssign(unittest.TestCase):
 
     def test_assign_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         var_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "var", var_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], var_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], var_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,42 +40,42 @@ class TestAssign(unittest.TestCase):
 
     def test_assign_value(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["value"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         value_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "value", value_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "variable"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], returnvalue)
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "assign")
 
     def test_assign_assign(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["assign"])[0]
         inst = self.mvs.execute("CNV", [{"value":"assign"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
@@ -83,23 +83,23 @@ class TestAssign(unittest.TestCase):
         variable = self.mvs.execute("CN", [])[0]
         value_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
-        self.mvs.execute("CD", [user_frame, "variable", variable])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "variable", variable])
         self.mvs.execute("CD", [variable, "value", value_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "variable"])[0], None)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "variable"])[0], None)
         self.assertEquals(self.mvs.execute("RD", [variable, "value"])[0], returnvalue)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], returnvalue)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], returnvalue)

kernel/test/rules/test_rules_break.py

@@ -11,8 +11,8 @@ class Testbreak(unittest.TestCase):
     def test_basic(self):
         # Create a break construct
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"break"}])[0]
         while_inst = self.mvs.execute("CNV", ["while"])[0]
@@ -20,23 +20,23 @@ class Testbreak(unittest.TestCase):
         evalstack_bottom = self.mvs.execute("CN", [])[0]
         finish_phase = self.mvs.execute("CNV", ["finish"])[0]
 
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack_top])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
         self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
         self.mvs.execute("CD", [evalstack_bottom, "inst", while_inst])
         self.mvs.execute("CD", [evalstack_bottom, "phase", finish_phase])
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "while", while_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
-        self.assertNotEquals(self.mvs.execute("RD", [user_frame, "evalstack"])[0], evalstack_top)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)

kernel/test/rules/test_rules_call.py

@@ -10,30 +10,30 @@ class Testcall(unittest.TestCase):
 
     def test_call_resolve_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         func = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "func", func])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -41,32 +41,32 @@ class Testcall(unittest.TestCase):
 
     def test_call_resolve_params(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         func = self.mvs.execute("CN", [])[0]
         params = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
         self.mvs.execute("CD", [inst, "func", func])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "params", params])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], func)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], func)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -74,31 +74,31 @@ class Testcall(unittest.TestCase):
 
     def test_call_execute_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["call"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "symbols", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "symbols", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [returnvalue, "body", body])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [user_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
         self.assertNotEquals(new_frame, None)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], new_frame)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
         new_symbols = self.mvs.execute("RD", [new_frame, "symbols"])[0]
@@ -114,12 +114,12 @@ class Testcall(unittest.TestCase):
         self.assertNotEquals(new_IP, None)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
 
     def test_call_execute_params(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["call"])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
@@ -132,13 +132,13 @@ class Testcall(unittest.TestCase):
         last_param = self.mvs.execute("CN", [])[0]
         formal_parameter = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [signature, "params", params])
@@ -153,20 +153,20 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], new_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        new_frame = self.mvs.execute("RD", [user_root, "frame"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], new_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        new_frame = self.mvs.execute("RD", [task_root, "frame"])[0]
         self.assertNotEquals(new_frame, None)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "IP"])[0], body)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
 
     def test_call_param_first_multi(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -178,11 +178,11 @@ class Testcall(unittest.TestCase):
         next_param = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", params])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", params])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [signature, "params", params])
         self.mvs.execute("CD", [inst, "params", params])
@@ -190,16 +190,16 @@ class Testcall(unittest.TestCase):
         self.mvs.execute("CD", [params, "next_param", next_param])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [returnvalue, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [user_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
         self.assertNotEquals(new_frame, None)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
@@ -214,16 +214,16 @@ class Testcall(unittest.TestCase):
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
         new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "phase"])[0], next_param)
 
     def test_call_param_first_single(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -234,26 +234,26 @@ class Testcall(unittest.TestCase):
         param_value = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", params])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", params])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [signature, "body", body])
         self.mvs.execute("CD", [inst, "params", params])
         self.mvs.execute("CD", [inst, "last_param", params])
         self.mvs.execute("CD", [params, "value", param_value])
         self.mvs.execute("CD", [returnvalue, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        new_frame = self.mvs.execute("RRD", [user_frame, "prev"])[0][0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        new_frame = self.mvs.execute("RRD", [task_frame, "prev"])[0][0]
         self.assertNotEquals(new_frame, None)
         new_evalstack = self.mvs.execute("RD", [new_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, None)
@@ -268,21 +268,21 @@ class Testcall(unittest.TestCase):
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [new_frame, "phase"])[0]])[0], "init")
         new_IP = self.mvs.execute("RD", [new_frame, "IP"])[0]
         self.assertNotEquals(new_IP, None)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         self.assertEquals(self.mvs.execute("RD", [new_frame, "caller"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], user_frame)
+        self.assertEquals(self.mvs.execute("RD", [new_frame, "prev"])[0], task_frame)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
         self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [evalstack, "phase"])[0]])[0], "call")
 
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
 
     def test_params_last(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -297,17 +297,17 @@ class Testcall(unittest.TestCase):
         formal_parameter = self.mvs.execute("CN", [])[0]
         formal_parameter_name = self.mvs.execute("CNV", ["param_a"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", last_param])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", last_param])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "last_param", last_param])
         self.mvs.execute("CD", [inst, "params", prev_param])
         self.mvs.execute("CD", [params, "value", param_value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [new_frame, "IP", body])
         self.mvs.execute("CD", [signature, "body", body])
@@ -322,14 +322,14 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
         var = self.mvs.execute("RDN", [symbols, formal_parameter])[0]
         self.assertNotEquals(var, None)
         self.assertEquals(self.mvs.execute("RD", [var, "value"])[0], returnvalue)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -337,8 +337,8 @@ class Testcall(unittest.TestCase):
 
     def test_params_next(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         inst = self.mvs.execute("CNV", [{"value":"call"}])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
@@ -355,17 +355,17 @@ class Testcall(unittest.TestCase):
         param_b = self.mvs.execute("CN", [])[0]
         param_c = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", param_b])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", param_b])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "params", self.mvs.execute("CN", [])[0]])
         self.mvs.execute("CD", [inst, "last_param", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [params, "value", param_value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [new_frame, "caller", inst])
-        self.mvs.execute("CD", [new_frame, "prev", user_frame])
+        self.mvs.execute("CD", [new_frame, "prev", task_frame])
         self.mvs.execute("CD", [new_frame, "symbols", symbols])
         self.mvs.execute("CD", [new_frame, "IP", body])
         self.mvs.execute("CD", [signature, "body", body])
@@ -381,11 +381,11 @@ class Testcall(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], param_value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], param_value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)

kernel/test/rules/test_rules_constant.py

@@ -10,26 +10,26 @@ class Testconstant(unittest.TestCase):
 
     def test_constant(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"constant"}])[0]
         node = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "node", node])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
         self.assertEquals(self.mvs.execute("RD", [inst, "node"])[0], node)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], node)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], node)

kernel/test/rules/test_rules_continue.py

@@ -11,8 +11,8 @@ class Testcontinue(unittest.TestCase):
     def test_basic(self):
         # Create a continue construct
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"continue"}])[0]
         while_inst = self.mvs.execute("CNV", ["while"])[0]
@@ -20,23 +20,23 @@ class Testcontinue(unittest.TestCase):
         evalstack_bottom = self.mvs.execute("CN", [])[0]
         init_phase = self.mvs.execute("CNV", ["finish"])[0]
 
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack_top])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack_top])
         self.mvs.execute("CD", [evalstack_top, "prev", evalstack_bottom])
         self.mvs.execute("CD", [evalstack_bottom, "inst", while_inst])
         self.mvs.execute("CD", [evalstack_bottom, "phase", init_phase])
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "while", while_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command inited, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
         self.assertEquals(self.mvs.execute("RD", [inst, "while"])[0], while_inst)
-        self.assertNotEquals(self.mvs.execute("RD", [user_frame, "evalstack"])[0], evalstack_top)
+        self.assertNotEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], evalstack_top)

kernel/test/rules/test_rules_helper.py

@@ -10,32 +10,32 @@ class TestHelper(unittest.TestCase):
 
     def test_next(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["finish"])[0]
         inst = self.mvs.execute("CN", [])[0]
         next_inst = self.mvs.execute("CNV", ["next"])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "next", next_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
         self.assertEquals(self.mvs.execute("RD", [inst, "next"])[0], next_inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], next_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], next_inst)
 
     def test_evalstack(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["finish"])[0]
         inst = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
@@ -43,11 +43,11 @@ class TestHelper(unittest.TestCase):
         evalstack_inst = self.mvs.execute("CN", [])[0]
         evalstack_phase = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [evalstack, "prev", prev_evalstack])
         self.mvs.execute("CD", [prev_evalstack, "inst", evalstack_inst])
         self.mvs.execute("CD", [prev_evalstack, "phase", evalstack_phase])
@@ -56,8 +56,8 @@ class TestHelper(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], evalstack_inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "phase"])[0], evalstack_phase)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "evalstack"])[0], prev_evalstack)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], evalstack_inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "phase"])[0], evalstack_phase)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "evalstack"])[0], prev_evalstack)

kernel/test/rules/test_rules_if.py

@@ -10,29 +10,29 @@ class Testif(unittest.TestCase):
 
     def test_if_evaluate_condition(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         cond = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "cond", cond])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class Testif(unittest.TestCase):
 
     def test_if_true(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [True])[0]
         then = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "then", then])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], then)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], then)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -72,31 +72,31 @@ class Testif(unittest.TestCase):
 
     def test_if_false_else(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
         else_inst = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
         self.mvs.execute("CD", [inst, "else", else_inst])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], else_inst)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], else_inst)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -104,25 +104,25 @@ class Testif(unittest.TestCase):
 
     def test_if_false_no_else(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"if"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)

kernel/test/rules/test_rules_input.py

@@ -10,8 +10,8 @@ class TestInput(unittest.TestCase):
 
     def test_input(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
         old_retval = self.mvs.execute("CN", [])[0]
@@ -19,12 +19,12 @@ class TestInput(unittest.TestCase):
         input_queue_next = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", old_retval])
-        self.mvs.execute("CD", [user_root, "input", input_queue_first])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", old_retval])
+        self.mvs.execute("CD", [task_root, "input", input_queue_first])
         self.mvs.execute("CD", [input_queue_first, "value", value])
         self.mvs.execute("CD", [input_queue_first, "next", input_queue_next])
 
@@ -32,36 +32,36 @@ class TestInput(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], value)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "input"])[0], input_queue_next)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], value)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_next)
 
     def test_input_none(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"input"}])[0]
         old_retval = self.mvs.execute("CN", [])[0]
         input_queue_first = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", old_retval])
-        self.mvs.execute("CD", [user_root, "input", input_queue_first])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", old_retval])
+        self.mvs.execute("CD", [task_root, "input", input_queue_first])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], old_retval)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "input"])[0], input_queue_first)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], old_retval)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "input"])[0], input_queue_first)

kernel/test/rules/test_rules_output.py

@@ -10,29 +10,29 @@ class TestOutput(unittest.TestCase):
 
     def test_output_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
         value = self.mvs.execute("CN", [])[0]
         evalstack = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
         self.mvs.execute("CD", [inst, "value", value])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(new_evalstack, evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class TestOutput(unittest.TestCase):
 
     def test_output_output(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["output"])[0]
         inst = self.mvs.execute("CNV", [{"value":"output"}])[0]
         retval = self.mvs.execute("CN", [])[0]
         output_queue = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", retval])
-        self.mvs.execute("CD", [user_root, "last_output", output_queue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", retval])
+        self.mvs.execute("CD", [task_root, "last_output", output_queue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], retval)
-        output_queue_next = self.mvs.execute("RD", [user_root, "last_output"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], retval)
+        output_queue_next = self.mvs.execute("RD", [task_root, "last_output"])[0]
         self.assertNotEquals(output_queue_next, output_queue)
         self.assertEquals(self.mvs.execute("RD", [output_queue, "next"])[0], output_queue_next)
         self.assertEquals(self.mvs.execute("RD", [output_queue, "value"])[0], retval)

kernel/test/rules/test_rules_resolve.py

@@ -10,8 +10,8 @@ class Testresolve(unittest.TestCase):
 
     def test_resolve_init_local(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CN", [])[0]
@@ -19,14 +19,14 @@ class Testresolve(unittest.TestCase):
         returnvalue = self.mvs.execute("CN", [])[0]
         entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
         t1 = self.mvs.execute("CE", [symbols, entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
@@ -35,19 +35,19 @@ class Testresolve(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
 
     def test_resolve_init_global(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         _globals = self.mvs.execute("CN", [])[0]
-        self.mvs.execute("CD", [user_root, "globals", _globals])
-        global_user = self.mvs.execute("RD", [user_root, "globals"])[0]
+        self.mvs.execute("CD", [task_root, "globals", _globals])
+        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CNV", ["var"])[0]
@@ -55,33 +55,33 @@ class Testresolve(unittest.TestCase):
         returnvalue = self.mvs.execute("CN", [])[0]
         entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
-        t1 = self.mvs.execute("CE", [global_user, entry])[0]
+        t1 = self.mvs.execute("CE", [global_task, entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], entry)
 
     def test_resolve_init_local_over_global(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
-        global_user = self.mvs.execute("RD", [user_root, "globals"])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
+        global_task = self.mvs.execute("RD", [task_root, "globals"])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"resolve"}])[0]
         var_inst = self.mvs.execute("CNV", ["var"])[0]
@@ -90,16 +90,16 @@ class Testresolve(unittest.TestCase):
         local_entry = self.mvs.execute("CN", [])[0]
         global_entry = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "var", var_inst])
-        self.mvs.execute("CD", [user_frame, "symbols", symbols])
-        self.mvs.execute("CD", [user_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
-        self.mvs.execute("CD", [user_frame, "evalstack", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "symbols", symbols])
+        self.mvs.execute("CD", [task_frame, "returnvalue", self.mvs.execute("CN", [])[0]])
+        self.mvs.execute("CD", [task_frame, "evalstack", self.mvs.execute("CN", [])[0]])
 
-        t1 = self.mvs.execute("CE", [global_user, global_entry])[0]
+        t1 = self.mvs.execute("CE", [global_task, global_entry])[0]
         self.mvs.execute("CE", [t1, var_inst])[0]
         t2 = self.mvs.execute("CE", [symbols, local_entry])[0]
         self.mvs.execute("CE", [t2, var_inst])[0]
@@ -108,8 +108,8 @@ class Testresolve(unittest.TestCase):
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "returnvalue"])[0], local_entry)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "returnvalue"])[0], local_entry)

kernel/test/rules/test_rules_return.py

@@ -10,50 +10,50 @@ class Testreturn(unittest.TestCase):
 
     def test_return_init(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         prev_stackframe = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "prev", prev_stackframe])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "prev", prev_stackframe])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
 
     def test_return_init_value(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         value = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "value", value])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], value)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], value)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -61,26 +61,26 @@ class Testreturn(unittest.TestCase):
 
     def test_return_eval(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["eval"])[0]
         inst = self.mvs.execute("CNV", [{"value":"return"}])[0]
         prev_stackframe = self.mvs.execute("CN", [])[0]
         returnvalue_top = self.mvs.execute("CN", [])[0]
         returnvalue_bottom = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "prev", prev_stackframe])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue_top])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "prev", prev_stackframe])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue_top])
         self.mvs.execute("CD", [prev_stackframe, "returnvalue", returnvalue_bottom])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], prev_stackframe)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], prev_stackframe)
         self.assertEquals(self.mvs.execute("RD", [prev_stackframe, "returnvalue"])[0], returnvalue_top)

kernel/test/rules/test_rules_while.py

@@ -10,29 +10,29 @@ class Testwhile(unittest.TestCase):
 
     def test_while_evaluate_condition(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["init"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         cond = self.mvs.execute("CN", [])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "cond", cond])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], cond)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], cond)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -40,31 +40,31 @@ class Testwhile(unittest.TestCase):
 
     def test_while_true(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         evalstack = self.mvs.execute("CN", [])[0]
         body = self.mvs.execute("CN", [])[0]
         returnvalue = self.mvs.execute("CNV", [True])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
         self.mvs.execute("CD", [inst, "body", body])
-        self.mvs.execute("CD", [user_frame, "evalstack", evalstack])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [task_frame, "evalstack", evalstack])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "init")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], body)
-        new_evalstack = self.mvs.execute("RD", [user_frame, "evalstack"])[0]
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "init")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], body)
+        new_evalstack = self.mvs.execute("RD", [task_frame, "evalstack"])[0]
         self.assertNotEquals(evalstack, new_evalstack)
         self.assertEquals(self.mvs.execute("RD", [new_evalstack, "prev"])[0], evalstack)
         self.assertEquals(self.mvs.execute("RD", [evalstack, "inst"])[0], inst)
@@ -72,23 +72,23 @@ class Testwhile(unittest.TestCase):
 
     def test_while_false(self):
         root = self.root
-        user_root = self.mvs.execute("CN", [])[0]
-        user_frame = self.mvs.execute("CN", [])[0]
+        task_root = self.mvs.execute("CN", [])[0]
+        task_frame = self.mvs.execute("CN", [])[0]
         phase = self.mvs.execute("CNV", ["cond"])[0]
         inst = self.mvs.execute("CNV", [{"value":"while"}])[0]
         returnvalue = self.mvs.execute("CNV", [False])[0]
 
-        self.mvs.execute("CD", [root, "user_1", user_root])
-        self.mvs.execute("CD", [user_root, "frame", user_frame])
-        self.mvs.execute("CD", [user_frame, "phase", phase])
-        self.mvs.execute("CD", [user_frame, "IP", inst])
-        self.mvs.execute("CD", [user_frame, "returnvalue", returnvalue])
+        self.mvs.execute("CD", [root, "task_1", task_root])
+        self.mvs.execute("CD", [task_root, "frame", task_frame])
+        self.mvs.execute("CD", [task_frame, "phase", phase])
+        self.mvs.execute("CD", [task_frame, "IP", inst])
+        self.mvs.execute("CD", [task_frame, "returnvalue", returnvalue])
 
         # Do the invocation until it returns None
         execute_until_finished(self.mvk, self.mvs)
 
         # Execution of the command finished, so the MvS should be in the correct new state right now
-        self.assertEquals(self.mvs.execute("RD", [root, "user_1"])[0], user_root)
-        self.assertEquals(self.mvs.execute("RD", [user_root, "frame"])[0], user_frame)
-        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [user_frame, "phase"])[0]])[0], "finish")
-        self.assertEquals(self.mvs.execute("RD", [user_frame, "IP"])[0], inst)
+        self.assertEquals(self.mvs.execute("RD", [root, "task_1"])[0], task_root)
+        self.assertEquals(self.mvs.execute("RD", [task_root, "frame"])[0], task_frame)
+        self.assertEquals(self.mvs.execute("RV", [self.mvs.execute("RD", [task_frame, "phase"])[0]])[0], "finish")
+        self.assertEquals(self.mvs.execute("RD", [task_frame, "IP"])[0], inst)

kernel/test/rules/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

kernel/test/utils.py

@@ -34,11 +34,11 @@ class MvSWrapper(object):
 
         return [retval[0]]
 
-def add_new_user(root, mvs, username):
+def add_new_task(root, mvs, taskname):
     hierarchy = mvs.execute("RD", [root, "__hierarchy"])[0]
     initial = mvs.execute("RD", [hierarchy, "__IP"])[0]
 
-    user_root = mvs.execute("CN", [])[0]
+    task_root = mvs.execute("CN", [])[0]
     _globals = mvs.execute("CN", [])[0]
     frame = mvs.execute("CN", [])[0]
     evalstack = mvs.execute("CN", [])[0]
@@ -48,13 +48,13 @@ def add_new_user(root, mvs, username):
     returnvalue = mvs.execute("CN", [])[0]
     phase = mvs.execute("CNV", ["init"])[0]
 
-    mvs.execute("CD", [root, username, user_root])
-    mvs.execute("CD", [user_root, "frame", frame])
-    mvs.execute("CD", [user_root, "globals", _globals])
-    mvs.execute("CD", [user_root, "input", _input])
-    mvs.execute("CD", [user_root, "last_input", _input])
-    mvs.execute("CD", [user_root, "output", _output])
-    mvs.execute("CD", [user_root, "last_output", _output])
+    mvs.execute("CD", [root, taskname, task_root])
+    mvs.execute("CD", [task_root, "frame", frame])
+    mvs.execute("CD", [task_root, "globals", _globals])
+    mvs.execute("CD", [task_root, "input", _input])
+    mvs.execute("CD", [task_root, "last_input", _input])
+    mvs.execute("CD", [task_root, "output", _output])
+    mvs.execute("CD", [task_root, "last_output", _output])
     mvs.execute("CD", [frame, "evalstack", evalstack])
     mvs.execute("CD", [frame, "returnvalue", returnvalue])
     mvs.execute("CD", [frame, "phase", phase])
@@ -62,12 +62,12 @@ def add_new_user(root, mvs, username):
     mvs.execute("CD", [frame, "symbols", symbols])
 
 def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
-    username = "user_1"
-    if operation == "initialize_new_user":
-        return add_new_user(mvk.root, mvs, username)
+    taskname = "task_1"
+    if operation == "initialize_new_task":
+        return add_new_task(mvk.root, mvs, taskname)
     response = None
     while 1:
-        mvs_commands = mvk.execute_yields(username, operation, params, response)
+        mvs_commands = mvk.execute_yields(taskname, operation, params, response)
         if mvs_commands is None:
             break
         response = []
@@ -75,37 +75,37 @@ def execute_until_finished(mvk, mvs, operation="execute_rule", params=[]):
             response.append(mvs.execute(command, param)[0])
 
 def get_inst(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    inst = mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    inst = mvs.execute("RD", [task_frame, "IP"])[0]
     return mvs.execute("RV", [inst])[0]["value"]
 
 def get_phase(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return mvs.execute("RV", [phase])[0]
 
 def get_returnvalue(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    returnvalue = mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    returnvalue = mvs.execute("RD", [task_frame, "returnvalue"])[0]
     return mvs.execute("RV", [returnvalue])[0]
 
 def get_inst_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "IP"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "IP"])[0]
 
 def get_returnvalue_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    return mvs.execute("RD", [user_frame, "returnvalue"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    return mvs.execute("RD", [task_frame, "returnvalue"])[0]
 
 def get_phase_ref(root, mvs):
-    user_root = mvs.execute("RD", [root, "user_1"])[0]
-    user_frame = mvs.execute("RD", [user_root, "frame"])[0]
-    phase = mvs.execute("RD", [user_frame, "phase"])[0]
+    task_root = mvs.execute("RD", [root, "task_1"])[0]
+    task_frame = mvs.execute("RD", [task_root, "frame"])[0]
+    phase = mvs.execute("RD", [task_frame, "phase"])[0]
     return phase
 
 def read_primitive_interfaces(root, mvs):

model/model.py

@@ -24,7 +24,7 @@ def get_object_constructor(code, filename):
     constructors = [3, "upload", filename, str(random.random()), True] + constructors + [False]
     return constructors
 
-def link_code(main_function, username, objects):
+def link_code(main_function, taskname, objects):
     return [3, "link_and_load"] + objects + ["", main_function]
 
 def translate(operation):
@@ -144,12 +144,12 @@ class MvKState(object):
         self.waiting = False
         self.inputs = {}
         self.outputs = {}
-        self.users = []
+        self.tasks = []
         self.reply = None
         self.phase = None
         self.commands = None
         self.root = None
-        self.current_user = None
+        self.current_task = None
         self.loaded_primitives = False
         self.execution_counter = 0
         self.all_failed = True
@@ -159,12 +159,12 @@ class MvKState(object):
                 "waiting: %s\n" % self.waiting + \
                 "inputs: %s\n" % self.inputs + \
                 "outputs: %s\n" % self.outputs + \
-                "users: %s\n" % self.users + \
+                "tasks: %s\n" % self.tasks + \
                 "reply: %s\n" % self.reply + \
                 "phase: %s\n" % self.phase + \
                 "commands: %s\n" % self.commands + \
                 "root: %s\n" % self.root + \
-                "current user: %s\n" % self.current_user + \
+                "current task: %s\n" % self.current_task + \
                 "execution counter: %s\n"
 
 class ModelverseKernel(AtomicDEVS):
@@ -183,12 +183,12 @@ class ModelverseKernel(AtomicDEVS):
         if self.from_mvi in inputs:
             # Got input from MvI, so we queue it
             for inp in inputs[self.from_mvi]:
-                username = inp[0]
+                taskname = inp[0]
                 data = inp[1]
                 if data is not None:
-                    self.state.inputs.setdefault(username, []).extend(data)
+                    self.state.inputs.setdefault(taskname, []).extend(data)
                 else:
-                    self.state.outputs.setdefault(username, []).append(None)
+                    self.state.outputs.setdefault(taskname, []).append(None)
 
         if self.from_mvs in inputs:
             # Got input from MvS, so we can continue processing
@@ -205,7 +205,7 @@ class ModelverseKernel(AtomicDEVS):
         return self.state
 
     def intTransition(self):
-        was_empty = len(self.state.users) == 0
+        was_empty = len(self.state.tasks) == 0
         if self.state.commands is not None:
             self.state.commands = None
             return self.state
@@ -223,44 +223,44 @@ class ModelverseKernel(AtomicDEVS):
             self.state.commands = commands
         else:
             # Are initialized and have work to do
-            if len(self.state.users) == 0:
-                # Read out new set of users first
+            if len(self.state.tasks) == 0:
+                # Read out new set of tasks first
                 if self.state.reply is None:
                     commands = [("RDK", [self.state.root])]
                 else:
-                    self.state.users = self.state.reply[0]
+                    self.state.tasks = self.state.reply[0]
                     commands = None
-            elif self.state.phase == "init_user":
+            elif self.state.phase == "init_task":
                 if self.state.reply is None:
-                    commands = [("RV", [self.state.users[0]])]
+                    commands = [("RV", [self.state.tasks[0]])]
                 else:
-                    self.state.current_user = self.state.reply[0]
-                    if self.state.current_user.startswith("__"):
-                        # Don't process this user and force termination of user
+                    self.state.current_task = self.state.reply[0]
+                    if self.state.current_task.startswith("__"):
+                        # Don't process this task and force termination of task
                         self.state.phase = "output"
                     commands = None
             elif self.state.phase == "input":
                 # Process inputs
-                if self.state.inputs.get(self.state.current_user, None):
-                    element_type, value = self.state.inputs[self.state.current_user][0]
-                    commands = self.state.mvk.execute_yields(self.state.current_user, "set_input", [element_type, value], self.state.reply)
+                if self.state.inputs.get(self.state.current_task, None):
+                    element_type, value = self.state.inputs[self.state.current_task][0]
+                    commands = self.state.mvk.execute_yields(self.state.current_task, "set_input", [element_type, value], self.state.reply)
                     if commands is None:
-                        self.state.inputs[self.state.current_user].pop(0)
+                        self.state.inputs[self.state.current_task].pop(0)
                 else:
                     commands = None
 
             elif self.state.phase == "computation":
-                commands = self.state.mvk.execute_yields(self.state.current_user, "execute_rule", [], self.state.reply)
+                commands = self.state.mvk.execute_yields(self.state.current_task, "execute_rule", [], self.state.reply)
             elif self.state.phase == "output":
-                commands = self.state.mvk.execute_yields(self.state.current_user, "get_output", [], self.state.reply)
+                commands = self.state.mvk.execute_yields(self.state.current_task, "get_output", [], self.state.reply)
             else:
                 raise Exception("Phase: " + str(self.state.phase))
 
             # Advance phase
             if commands is None:
                 if was_empty:
-                    self.state.phase = "init_user"
-                elif self.state.phase == "init_user":
+                    self.state.phase = "init_task"
+                elif self.state.phase == "init_task":
                     self.state.phase = "input"
                 elif self.state.phase == "input":
                     self.state.phase = "computation"
@@ -271,8 +271,8 @@ class ModelverseKernel(AtomicDEVS):
                     else:
                         self.state.execution_counter += 1
                 elif self.state.phase == "output":
-                    self.state.users.pop(0)
-                    self.state.phase = "init_user"
+                    self.state.tasks.pop(0)
+                    self.state.phase = "init_task"
                 self.state.waiting = False
                 self.state.reply = None
             else:
@@ -292,7 +292,7 @@ class ModelverseKernel(AtomicDEVS):
         return {}
 
     def timeAdvance(self):
-        if self.state.phase == "init_user" and self.state.all_failed:
+        if self.state.phase == "init_task" and self.state.all_failed:
             # Make this a parameter
             return 200
         if self.state.commands is not None:
@@ -313,11 +313,11 @@ class MvIState():
         self.init = True
 
 class ModelverseInterface(AtomicDEVS):
-    def __init__(self, username, operations):
-        AtomicDEVS.__init__(self, "MvI_%s" % username)
+    def __init__(self, taskname, operations):
+        AtomicDEVS.__init__(self, "MvI_%s" % taskname)
         self.state = MvIState()
         self.state.operations = operations
-        self.username = username
+        self.taskname = taskname
 
         self.to_mvk = self.addOutPort("to_MvK")
         self.from_mvk = self.addInPort("from_MvK")
@@ -340,7 +340,7 @@ class ModelverseInterface(AtomicDEVS):
         return self.state
 
     def outputFnc(self):
-        return {self.to_mvk: [(self.username, self.state.operations)]}
+        return {self.to_mvk: [(self.taskname, self.state.operations)]}
 
     def timeAdvance(self):
         if self.state.init:
@@ -392,7 +392,7 @@ class Network(AtomicDEVS):
 
 class System(CoupledDEVS):
     def __init__(self,
-                username,
+                taskname,
                 operations,
                 rules_per_phase,
                 mvi2mvk_latency,
@@ -423,11 +423,11 @@ class System(CoupledDEVS):
         CoupledDEVS.__init__(self, "System")
 
         self.mvi_manager = self.addSubModel(ModelverseInterface(\
-                            username            = "user_manager",
-                            operations          = [username],
+                            taskname            = "task_manager",
+                            operations          = [taskname],
                         ))
         self.mvi = self.addSubModel(ModelverseInterface(\
-                            username            = username,
+                            taskname            = taskname,
                             operations          = operations
                         ))
         self.mvk = self.addSubModel(ModelverseKernel(\
@@ -492,17 +492,17 @@ Void function main():
 \tlog("Executed the code!")
 \treturn !
     """
-username = "test_user"
+taskname = "test_task"
 
 operations = [get_object_constructor(open(f, 'r').read(), str(f)) for f in files] + \
               get_object_constructor(code, "main") + \
-              link_code("main", username, files + ["code.alc"])
+              link_code("main", taskname, files + ["code.alc"])
 
 print("Generated operations:")
 print(operations)
 
 args = {
-        "username":             username,
+        "taskname":             taskname,
         "operations":           operations,
         "mvi2mvk_latency":      1,
         "mvi2mvk_bandwidth":    2000,

performance/utils.py

@@ -17,7 +17,7 @@ sys.path.append("scripts")
 from hutn_compiler.compiler import main as do_compile
 from check_objects import to_recompile
 
-USERNAME = "test_user"
+USERNAME = "test_task"
 PARALLEL_PUSH = True
 
 BOOTSTRAP_FOLDER_NAME = "bootstrap"
@@ -35,7 +35,7 @@ ALL_OPTIMIZATION_LEVELS = [
 ]
 
 class ModelverseTerminated(Exception):
-    """An exception that tells the user that the Modelverse has terminated."""
+    """An exception that tells the task that the Modelverse has terminated."""
     pass
 
 def get_code_folder_name():
@@ -80,7 +80,7 @@ def set_input_data(address, data):
             urllib2.Request(
                 address,
                 urllib.urlencode(
-                    {"op": "set_input", "data": json.dumps(data), "username": USERNAME})),
+                    {"op": "set_input", "data": json.dumps(data), "taskname": USERNAME})),
             timeout=10).read()
     else:
         return []
@@ -90,10 +90,10 @@ def compile_file(address, mod_filename, filename, mode, proc):
     # Load in the file required
     try:
         timeout_val = 240
-        username = str(random.random())
+        taskname = str(random.random())
         while 1:
             proc2 = execute(
-                "compile", [address, mod_filename, username, filename, mode], wait=False)
+                "compile", [address, mod_filename, taskname, filename, mode], wait=False)
 
             if proc.returncode is not None:
                 # Modelverse has already terminated, which isn't a good sign!
@@ -181,7 +181,7 @@ def run_file(files, parameters, mode, handle_output, optimization_level=None):
             val = urllib2.urlopen(
                 urllib2.Request(
                     address,
-                    urllib.urlencode({"op": "get_output", "username": USERNAME})),
+                    urllib.urlencode({"op": "get_output", "taskname": USERNAME})),
                 timeout=240).read()
             val = json.loads(val)
 

scripts/check_objects.py

@@ -6,17 +6,17 @@ import hashlib
 import time
 
 def to_recompile(address, files):
-    username = str(random.random())
+    taskname = str(random.random())
     files = sorted(files)
     rebuild = []
 
     def flush_data(data):
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname}))).read()
 
     while 1:
         try:
-            # Create new user
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+            # Create new task
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
             break
         except:
             time.sleep(0.01)
@@ -33,7 +33,7 @@ def to_recompile(address, files):
         md5_values[f] = md5.hexdigest()
 
     for f in files:
-        v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+        v = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
         mv_md5 = json.loads(v)
         if md5_values[f] == mv_md5:
             # Identical, so don't rebuild
@@ -43,5 +43,5 @@ def to_recompile(address, files):
             # Different, so rebuild
             rebuild.append(f)
 
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '-1', "username": username}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '-1', "taskname": taskname}))).read()
     return rebuild

scripts/compile.py

@@ -5,7 +5,7 @@ import urllib
 import subprocess
 import time
 
-def do_compile(address, filename, username, modulename, mode, optionals=['--debug'], grammar=""):
+def do_compile(address, filename, taskname, modulename, mode, optionals=['--debug'], grammar=""):
     filename = os.path.realpath(filename)
     if grammar == "":
         if mode[0] == "M":
@@ -15,10 +15,10 @@ def do_compile(address, filename, username, modulename, mode, optionals=['--debu
             # Load AL grammar
             grammar = "grammars/actionlanguage.g"
 
-    # Create new user
+    # Create new task
     try:
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
-        subprocess.check_call([sys.executable, "hutn_compiler/compiler.py", filename, grammar, mode, username, modulename, filename, address] + optionals, cwd="interface/HUTN")
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
+        subprocess.check_call([sys.executable, "hutn_compiler/compiler.py", filename, grammar, mode, taskname, modulename, filename, address] + optionals, cwd="interface/HUTN")
         return 0
     except:
         return 1
@@ -26,13 +26,13 @@ def do_compile(address, filename, username, modulename, mode, optionals=['--debu
 if __name__ == "__main__":
     if len(sys.argv) != 6:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address filename username modulename mode\n" % sys.argv[0])
+        sys.stderr.write("    %s address filename taskname modulename mode\n" % sys.argv[0])
         sys.exit(1)
     else:
         address = sys.argv[1]
         filename = sys.argv[2]
-        username = sys.argv[3]
+        taskname = sys.argv[3]
         modulename = sys.argv[4]
         mode = sys.argv[5]
         
-        sys.exit(do_compile(address, filename, username, modulename, mode))
+        sys.exit(do_compile(address, filename, taskname, modulename, mode))

scripts/debug_prompt.py

@@ -25,11 +25,11 @@ location = raw_input()
 if location == "":
     address = "http://127.0.0.1:8001/"
     
-local_print("Please specify user name (default: test)")
+local_print("Please specify task name (default: test)")
 
-username = raw_input()
+taskname = raw_input()
 if location == "":
-    username = "test"
+    taskname = "test"
 
 local_print("Switching context to Modelverse: all data is piped.")
 local_print("Available commands: 'pause', 'resume'")
@@ -42,4 +42,4 @@ while 1:
         local_print("Received quit: breaking connection to Modelverse immediately!")
         break
 
-    print json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": action, "username": username}))).read())
+    print json.loads(urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": action, "taskname": taskname}))).read())

scripts/execute_model.py

@@ -12,7 +12,7 @@ models = []
 code = []
 
 address = sys.argv[1]
-username = sys.argv[2]
+taskname = sys.argv[2]
 files = [a.replace("\\", "/") for a in sum([glob.glob(f) for f in sys.argv[3:]], [])]
 
 for f in files:
@@ -28,12 +28,12 @@ def initialize_SCD():
     import urllib2
     import urllib
     import json
-    username = random.random()
+    taskname = random.random()
 
     while 1:
         try:
-            # Create new user
-            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+            # Create new task
+            urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
             break
         except:
             time.sleep(0.01)
@@ -46,8 +46,8 @@ def initialize_SCD():
     data.append(2)
 
     print("Initializing SCD")
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username}))).read()
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
     print("Initialized!")
 
 def do_compile_wrapper(filename, mode, grammar):
@@ -60,4 +60,4 @@ for m in models:
     print("[MODEL] %s" % m)
     do_compile_wrapper(m, "MO", "grammars/modelling.g")
 
-main(address, username, code)
+main(address, taskname, code)

scripts/link_and_load.py

@@ -1,20 +1,20 @@
 import sys
 import urllib2
 
-def link_and_load(address, username, objs):
-    urllib2.urlopen(urllib2.Request(address, 'op=set_input&username=user_manager&value="%s"' % username)).read()
+def link_and_load(address, taskname, objs):
+    urllib2.urlopen(urllib2.Request(address, 'op=set_input&taskname=task_manager&value="%s"' % taskname)).read()
 
     sys.path.append("interface/HUTN")
     from hutn_compiler.linker import link
-    link(address, username, objs)
+    link(address, taskname, objs)
 
 if __name__ == "__main__":
     if len(sys.argv) < 4:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address username [files]*\n")
+        sys.stderr.write("    %s address taskname [files]*\n")
     else:
         address = sys.argv[1]
-        username = sys.argv[2]
+        taskname = sys.argv[2]
         objs = sys.argv[3:]
 
-        link_and_load(address, username, objs)
+        link_and_load(address, taskname, objs)

scripts/make_all.py

@@ -9,14 +9,14 @@ import glob
 if __name__ == "__main__":
     if len(sys.argv) < 4:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address username [file]*\n")
+        sys.stderr.write("    %s address taskname [file]*\n")
     else:
         address = sys.argv[1]
-        username = sys.argv[2]
+        taskname = sys.argv[2]
         files = [a.replace("\\", "/") for a in sum([glob.glob(f) for f in sys.argv[3:]], [])]
 
         new_files = to_recompile(address, files)
         for f in new_files:
             do_compile(address, f, str(random.random()), f, "PO", ["--debug"])
 
-        link_and_load(address, username, files)
+        link_and_load(address, taskname, files)

scripts/make_parallel.py

@@ -8,24 +8,24 @@ import multiprocessing
 import glob
 
 def do_compile_wrapper(args):
-    address, username, filename = args
+    address, taskname, filename = args
     do_compile(address, filename, str(random.random()), filename, "PO", ["--debug"])
 
-def main(address, username, files):
+def main(address, taskname, files):
     p = multiprocessing.Pool(multiprocessing.cpu_count() * 2)
     new_files = to_recompile(address, files)
-    p.map(do_compile_wrapper, [[address, username, f] for f in new_files])
-    link_and_load(address, username, files)
+    p.map(do_compile_wrapper, [[address, taskname, f] for f in new_files])
+    link_and_load(address, taskname, files)
 
 if __name__ == "__main__":
     if len(sys.argv) < 4:
         sys.stderr.write("Expected different parameters!\n")
-        sys.stderr.write("    %s address username [file]*\n" % sys.argv[0])
+        sys.stderr.write("    %s address taskname [file]*\n" % sys.argv[0])
         sys.exit(1)
 
     address = sys.argv[1]
-    username = sys.argv[2]
+    taskname = sys.argv[2]
     files = [a.replace("\\", "/") for a in sum([glob.glob(f) for f in sys.argv[3:]], [])]
 
-    main(address, username, files)
+    main(address, taskname, files)
 

scripts/process.py

@@ -1,10 +1,10 @@
-def flush_data(address, username, data):
+def flush_data(address, taskname, data):
     if data:
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "username": username})), timeout=10).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(data), "taskname": taskname})), timeout=10).read()
     return []
 
-def fetch_output(address, username):
-    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username})), timeout=10).read()
+def fetch_output(address, taskname):
+    val = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})), timeout=10).read()
     l, r = output.split("&", 1)
     if "value" in l:
         output = r
@@ -13,14 +13,14 @@ def fetch_output(address, username):
     _, output = output.split("=", 1)
     return output
 
-def send_to_mv(address, username, lst):
+def send_to_mv(address, taskname, lst):
     data = []
     variables = {}
 
     for c in lst:
         if isinstance(c, int):
-            data = flush_data(address, username, data)
-            variables[c] = fetch_output(address, username)
+            data = flush_data(address, taskname, data)
+            variables[c] = fetch_output(address, taskname)
         else:
             data.append(c)
 

scripts/prompt.py

@@ -12,8 +12,8 @@ from hutn_compiler.compiler import main as hutn_compile
 
 memory = {}
 
-def send_data(commands, address, username):
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(commands), "username": username}))).read()
+def send_data(commands, address, taskname):
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "data": json.dumps(commands), "taskname": taskname}))).read()
 
 def local_print(string):
     if os.name == "posix":
@@ -33,13 +33,13 @@ try:
 except IndexError:
     address = "http://127.0.0.1:8001"
 try:
-    username = sys.argv[2]
+    taskname = sys.argv[2]
 except IndexError:
     import random
-    username = str(random.random())
+    taskname = str(random.random())
 
-# If user doesn't exist yet, we create it
-urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % username, "username": "user_manager"}))).read()
+# If task doesn't exist yet, we create it
+urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % taskname, "taskname": "task_manager"}))).read()
 
 local_print("Switching context to Modelverse: all data is piped.")
 local_print("Use command $ to switch to HUTN parsing mode.")
@@ -48,7 +48,7 @@ local_print("To quit: execute command 'quit'")
 
 def print_output():
     while 1:
-        output = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "username": username}))).read()
+        output = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname}))).read()
         remote_print("%s" % str(json.loads(output)))
 
 thrd = threading.Thread(target=print_output)
@@ -101,4 +101,4 @@ while 1:
         else:
             command = '"%s"' % command
 
-        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": command, "username": username}))).read()
+        urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": command, "taskname": taskname}))).read()

scripts/run_MvC_server.py

@@ -10,7 +10,7 @@ MVK_PORT = 8001
 MVK_ADDRESS = "http://localhost"
 ADMIN_USER = "admin"
 ADMIN_PASSWORD = "admin"
-SETUP_USER = "setup_user"
+SETUP_USER = "setup_task"
 
 address = "%s:%s" % (MVK_ADDRESS, MVK_PORT)
 
@@ -24,11 +24,11 @@ try:
     # Compile all MvC code
     subprocess.call([sys.executable, "scripts/execute_model.py", address, SETUP_USER, "bootstrap/*.alc", "core/*.alc", "core/*.mvc"])
 
-    # Set the admin username and password
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_USER, "username": SETUP_USER}))).read()
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_PASSWORD, "username": SETUP_USER}))).read()
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_PASSWORD, "username": SETUP_USER}))).read()
-    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"exit"', "username": SETUP_USER}))).read()
+    # Set the admin taskname and password
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_USER, "taskname": SETUP_USER}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_PASSWORD, "taskname": SETUP_USER}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"%s"' % ADMIN_PASSWORD, "taskname": SETUP_USER}))).read()
+    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": '"exit"', "taskname": SETUP_USER}))).read()
 
     while 1:
         time.sleep(1)