initial commit

Author: MarcG-TUE

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+models
+.vscode
+.noseids
+nosetests.xml

.gitlab-ci.yml

@@ -0,0 +1,13 @@
+build:
+    tags:
+        - Ubuntu1804-64bit
+    script:
+        - sudo apt-get -y update
+        - sudo apt-get -y install python3-pip libcairo2-dev
+        - cd /builds/mgeilen/cmtrace 
+        - bash ./ci/script/test.sh
+    artifacts:
+      expire_in: 14d
+      when: always
+      paths:
+      - /builds/mgeilen/cmtrace/packages/cmtrace/cmtrace/test/output/

package/cmtrace/.gitignore

@@ -0,0 +1,11 @@
+build
+
+# Compiled python modules.
+*.pyc
+
+# Setuptools distribution folder.
+/dist/
+
+# Python egg metadata, regenerated from source files by setuptools.
+/*.egg-info
+.eggs

package/cmtrace/MANIFEST.in

@@ -0,0 +1,2 @@
+include example/trace.xml
+include example/settings.yaml

package/cmtrace/cmtrace/__init__.py

@@ -0,0 +1,92 @@
+"""Class Actor Represents an actor in a dataflow graph"""
+
+from cmtrace.dataflow.maxplus import mpplus, mpmax, mpmax2, trace, MPMINUSINF, output_sequence
+
+class Actor:
+    """Represents an actor in a dataflow graph"""
+    def __init__(self, name, actdelay, scenario=None):
+        self.name = name
+        self.delay = actdelay
+        self.inputs = dict()
+        self.primary_inputs = []
+        self.state_inputs = dict()
+        self.firings = []
+        self.scenario = scenario
+
+    def add_channel_input(self, actor, initial_tokens=0, arcdelay=0, initial_time=MPMINUSINF):
+        """add a channel input dependency to another actor, including
+        a time-offset arcdelay"""
+        self.inputs[actor.name] = (actor, initial_tokens, arcdelay, initial_time)
+
+    def add_state_input(self, state, tokendelay=0, arcdelay=0):
+        """Add a dependency on a state token for an SADF graph"""
+        self.state_inputs[state.name] = (state, tokendelay, arcdelay)
+        return
+
+    def add_primary_input(self, priminput):
+        """Add dependency to a primary input to the graph."""
+        self.primary_inputs.append(priminput)
+
+    def completions(self):
+        """returns the current completion times of the actor"""
+        # add the actor delay to the firing times
+        return mpplus(self.firings, self.delay)
+
+    def firing_intervals(self):
+        """ Return a list of (start,end) pairs for all firings """
+        return [(f, f+self.delay) for f in self.firings]
+
+    def update_firings(self):
+        """Recomput the firings of the actor based on its input dependencies.
+        Returns a boolean indicating if the computed firings remained the same."""
+        oldfirings = len(self.firings)
+        traces = []
+        # collect all the incoming channels
+        for i, (act, tok, arcdel, tokinit) in self.inputs.items():
+            traces.append(output_sequence(act.completions(), tok, arcdel, tokinit))
+        # collect traces for all primary inputs
+        for i in self.primary_inputs:
+            traces.append(i)
+        if len(traces) == 0:
+            raise Exception("Actor must have inputs")
+
+        # determine the firings
+        self.firings = mpmax(*traces)
+        return oldfirings == len(self.firings)
+
+    def set_scenario(self, scenario):
+        """set the scenario in which the actor is active"""
+        self.scenario = scenario
+
+    def update_firings_sadf(self, scen_seq):
+        """Recomput the firings of the SADF actor based on its input dependencies.
+        Returns a boolean indicating if the computed firings remained the same."""
+        # update the actor firings
+        oldfirings = len(self.firings)
+
+        # primary inputs
+        # assume for the moment that primary inputs are active in only one scenario!
+        # hack to deal with absence of primary inputs. Should be an infinitely
+        # long sequence of minus inf.
+        if len(self.primary_inputs) > 0:
+            self.firings = mpmax(*self.primary_inputs)
+        else:
+            self.firings = [MPMINUSINF] * len(scen_seq)
+
+        # state_inputs
+        for _, (state, tokdel, arcdel) in self.state_inputs.items():
+            if self.scenario is None:
+                raise Exception("SADF actor has no scenario.")
+            splicedfirings = state.spliced_firings(scen_seq, self.scenario, tokdel)
+            self.firings = mpmax2(self.firings, mpplus(splicedfirings, arcdel))
+
+        # channel inputs
+        for _, (act, tok, arcdel, tokinit) in self.inputs.items():
+            self.firings = mpmax2(self.firings, output_sequence(act.completions(), tok, arcdel, tokinit))
+
+        return oldfirings == len(self.firings)
+
+
+    def get_trace(self, tracelength):
+        """Get a string representation of the actor's execution trace."""
+        return trace(self.firings, self.delay, tracelength)

package/cmtrace/cmtrace/dataflow/__init__.py

@@ -0,0 +1,33 @@
+"""Implements the denotational semantics of open datflow models."""
+
+def compute_fixpoint(actors):
+    """Perform the Kahn fix-point computation of the SDF semantics."""
+    fixpoint = False
+    # continue till a fixpoint is reached
+    while not fixpoint:
+        fixpoint = True
+        for actor in actors:
+            res = actor.update_firings()
+            # do not combine this line with the above, because and is lazy
+            fixpoint = fixpoint and res
+
+
+def compute_fixpoint_sadf(scen_seq, actors, states):
+    """Perform the Kahn fix-point computation of the SADF semantics."""
+    fixpoint = False
+    # continue till a fixpoint is reached
+    while not fixpoint:
+        fixpoint = True
+        # splice traces across scenarios following the scenario sequence
+        # update the actors in all scenarios
+        for actor in actors:
+            # update actor a
+            res = actor.update_firings_sadf(scen_seq)
+            # do not combine this line with the above, because and is lazy
+            fixpoint = fixpoint and res
+        # update the states
+        for state in states:
+            res = state.update_state_sadf(scen_seq)
+            fixpoint = fixpoint and res
+
+    return

package/cmtrace/cmtrace/dataflow/actor.py

@@ -0,0 +1,63 @@
+"""A library for maxplus algebra and signals."""
+
+from functools import reduce
+
+
+# quick and dirty implementation of MPMINUSINFINITY
+MPMINUSINF = -1000
+MPMINUSTHRESHOLD = MPMINUSINF >> 1
+
+# special value to denote the infinitely long sequence of MINUSINF values
+# the neutral element of max over sequences.
+ZEROSEQ = -1
+
+def delay(events, number_of_tokens, initial_time=MPMINUSINF):
+    """Delay an event sequence by n tokens. n may be negative, in which case tokens will be removed."""
+    if number_of_tokens >= 0:
+        return initialtokens(number_of_tokens, initial_time) + events
+    else:
+        return events[-number_of_tokens:]
+
+
+def initialtokens(number_of_tokens, initial_time=MPMINUSINF):
+    """
+    Return an event sequence of the given length with -infty values, or a specific value
+    passed as the second argument
+    """
+    return [initial_time] * number_of_tokens
+
+def mpmax2(seq1, seq2):
+    """Compute the max operation on two event sequences."""
+    return list(map(lambda l: max(l), zip(seq1, seq2)))
+
+
+def mpmax(*args):
+    """Compute the max operation on an arbitrary number of sequences"""
+    if len(args) == 0:
+        return ZEROSEQ
+    return reduce(lambda s1, s2: mpmax2(s1, s2), args)
+
+def mpplus(seq, timedelay):
+    """Add a time delay to a sequence"""
+    return [x+timedelay for x in seq]
+
+def output_sequence(input_sequence, initial_tokens, arcdelay, initial_time=MPMINUSINF):
+    """Apply a token delay and a time delay to a sequence"""
+    return mpplus(delay(input_sequence, initial_tokens, initial_time), arcdelay)
+
+def trace(seq, duration, tracelen):
+    """Create a string representation of an execution trace of the
+    given length with starting times in seq, with firings of the given duration. """
+    tracestr = ''
+    newseq = list(seq) + [1000]
+    for k in range(tracelen):
+        if len(newseq) == 0:
+            return tracestr
+        while newseq[0]+duration <= k:
+            newseq = newseq[1:]
+        if k < newseq[0]:
+            tracestr += '-'
+        else:
+            tracestr += '*'
+    return tracestr
+

package/cmtrace/cmtrace/dataflow/dataflow.py

@@ -0,0 +1,56 @@
+"""Class State Represents the SADF graph state inbetween scenarios"""
+from cmtrace.dataflow.maxplus import delay
+
+class State:
+    """Represents the SADF graph state inbetween scenarios"""
+
+    def __init__(self, name, input_scenarios, output_scenarios):
+        self.input_scenarios = input_scenarios
+        self.output_scenarios = output_scenarios
+        self.name = name
+        self.providers = dict()
+        self.firings = []
+
+    def set_provider(self, scenario, actor):
+        """Set the actor that provides the state in the given scenario"""
+        # production in scenarion is done by actor at the end of its firing
+        self.providers[scenario] = actor
+        return
+
+    def spliced_firings(self, scen_seq, scen, tokdel):
+        """return the firings, spliced for scenario scen in sequence scen_seq.
+        """
+        del_firings = delay(self.firings, tokdel)
+        kix = mix = 0
+        splice = []
+        while mix < len(del_firings) and kix < len(scen_seq):
+            if scen_seq[kix] in self.input_scenarios:
+                if scen_seq[kix] == scen:
+                    splice.append(del_firings[mix])
+                mix += 1
+            kix += 1
+        return splice
+
+    def update_state_sadf(self, scen_seq):
+        """Update the state from the state providers for the given scenario sequence.
+        Return a boolean indicating if the sequence remained the same."""
+        old_firings = len(self.firings)
+        prov_firings = dict()
+        indices = dict()
+        for scenario, actor in self.providers.items():
+            prov_firings[scenario] = actor.completions()
+            indices[scenario] = 0
+        self.firings = []
+        for (k, _) in enumerate(scen_seq):
+            # if the current scenario outputs to this state
+            if scen_seq[k] in self.output_scenarios:
+                scenario = scen_seq[k]
+                # if there are no more remaining events
+                if indices[scenario] >= len(prov_firings[scenario]):
+                    # then the output stops here
+                    break
+                # otherwise add the event
+                self.firings.append(prov_firings[scenario][indices[scenario]])
+                # update the index for the scenario
+                indices[scenario] += 1
+        return old_firings == len(self.firings)