Merge pull request praalhans#28 from praalhans/feature/18

Feature/18

Author: sshann

SimulationCore/src/com/aexiz/daviz/simulation/AbstractEvent.java

@@ -10,6 +10,10 @@
 import com.aexiz.daviz.simulation.viewpoint.Locus;
 import com.aexiz.daviz.simulation.viewpoint.Node;
 
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 public abstract class AbstractEvent extends Locus implements Cloneable, Event {
     protected Simulation simulation;
     protected Execution execution;
@@ -142,6 +146,26 @@ public Node getReceiver() {
         throw new Error();
     }
 
+    @Override
+    public void clearMatchingEvent() {
+        matchingEvent = null;
+    }
+
+    @Override
+    public void clearPreviousEvent() {
+        previousEvent = null;
+    }
+
+    @Override
+    public void setPreviousEvent(Event previousEvent) {
+        this.previousEvent = previousEvent;
+    }
+
+    @Override
+    public void setMatchingEvent(Event matchingEvent) {
+        this.matchingEvent = matchingEvent;
+    }
+
     @Override
     public abstract Event clone();
 
@@ -151,4 +175,60 @@ protected AbstractEvent clone(AbstractEvent to) {
         to.happensAt = this.happensAt;
         return to;
     }
+
+    static public void matchAndLinkEvents(List<Event> events) {
+        // First we clear the state of all events
+        clearEvents(events);
+
+        // Match send and receive events
+        matchSendAndReceiveEvents(events);
+
+        // Build a linked list of events and their predecessor within the same process
+        linkPreviousEvents(events);
+    }
+
+    private static void clearEvents(List<Event> events) {
+        for (Event event : events) {
+            event.clearMatchingEvent();
+            event.clearPreviousEvent();
+        }
+    }
+
+    private static void matchSendAndReceiveEvents(List<Event> events) {
+        for (int i = 0, size = events.size(); i < size; i++) {
+            Event receiveEvent = events.get(i);
+            if (receiveEvent instanceof tReceiveEvent) {
+                boolean matched = false;
+                for (int j = 0; j < i; j++) {
+                    Event sendEvent = events.get(j);
+                    if (sendEvent instanceof tSendEvent && areEventsMatched(sendEvent, receiveEvent)) {
+                        sendEvent.setMatchingEvent(receiveEvent);
+                        receiveEvent.setMatchingEvent(sendEvent);
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched)
+                    throw new Error("Unmatched receive and send events");
+            }
+        }
+    }
+
+    private static boolean areEventsMatched(Event sendEvent, Event receiveEvent) {
+        if (sendEvent.getReceiver() != receiveEvent.getHappensAt()) return false;
+        if (receiveEvent.getSender() != sendEvent.getHappensAt()) return false;
+        if (sendEvent.hasMatchingEvent()) return false;
+        if (!receiveEvent.getMessage().equals(sendEvent.getMessage())) return false;
+
+        return true;
+    }
+
+    private static void linkPreviousEvents(List<Event> events) {
+        Map<Node, Event> map = new HashMap<>();
+        for (Event event : events) {
+            Node happens = event.getHappensAt();
+            event.setPreviousEvent(map.get(happens));
+            map.put(happens, event);
+        }
+    }
 }

SimulationCore/src/com/aexiz/daviz/simulation/AbstractExecution.java

@@ -18,6 +18,23 @@ public abstract class AbstractExecution implements Execution {
      */
     Event lastEvent;
 
+    public AbstractExecution(Simulation simulation, Configuration configuration) {
+        this.simulation = simulation;
+        this.configuration = configuration;
+    }
+
+    public AbstractExecution(Simulation simulation, Execution parent) {
+        this.simulation = simulation;
+        this.parent = parent;
+    }
+
+    public AbstractExecution(Simulation simulation) {
+        this.simulation = simulation;
+    }
+
+    public AbstractExecution() {
+    }
+
     protected void isInvariant() {
         if (simulation == null) throw new Error("Invalid simulation");
     }
@@ -65,6 +82,11 @@ public void setLastEvent(Event lastEvent) {
         this.lastEvent = lastEvent;
     }
 
+    @Override
+    public Event getLastEvent() {
+        return lastEvent;
+    }
+
     @Override
     public boolean hasNext() {
         return successors.size() != 0;
@@ -120,4 +142,19 @@ public List<Execution> getExecutionPath() {
         Collections.reverse(result);
         return result;
     }
+
+    @Override
+    public Event[] getLinkedEvents() {
+        ArrayList<Event> events = new ArrayList<>();
+        // Traverse and collect
+        Execution elem = this;
+        while (elem.hasEvents()) {
+            events.add(elem.getLastEvent());
+            elem = elem.getParent();
+        }
+
+        Collections.reverse(events);
+        AbstractEvent.matchAndLinkEvents(events);
+        return events.toArray(new Event[0]);
+    }
 }

SimulationCore/src/com/aexiz/daviz/simulation/AbstractNetwork.java

@@ -4,8 +4,7 @@
 import com.aexiz.daviz.simulation.viewpoint.Node;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
-import java.util.UUID;
+import java.util.*;
 
 public abstract class AbstractNetwork implements Network {
     protected ArrayList<Node> processes = new ArrayList<>();
@@ -127,6 +126,30 @@ public boolean belongsToSimulation() {
         return simulationUUID != null;
     }
 
+    @Override
+    public List<Channel> getChannelsFromNode(Node node) {
+        List<Channel> channels = new ArrayList<>();
+
+        this.channels.forEach((channel) -> {
+            if (channel.from.isEqualTo(node)) {
+                channels.add(channel);
+            }
+        });
+
+        return channels;
+    }
+
+    @Override
+    public Map<Node, List<Channel>> makeMapOfChannelsFromNodes() {
+        Map<Node, List<Channel>> channelsFromNode = new HashMap<>();
+
+        processes.forEach((process) -> {
+            channelsFromNode.put(process, getChannelsFromNode(process));
+        });
+
+        return channelsFromNode;
+    }
+
     private void floodFill(@NotNull Node node) {
         if (node.isMarked()) return;
         node.setMarked(true);

SimulationCore/src/com/aexiz/daviz/simulation/Event.java

@@ -18,12 +18,20 @@ public interface Event {
 
     Node getHappensAt();
 
+    void clearPreviousEvent();
+
+    void setPreviousEvent(Event event);
+
     void setHappensAt(Node happensAt);
 
     boolean hasMatchingEvent();
 
     Event getMatchingEvent();
 
+    void clearMatchingEvent();
+
+    void setMatchingEvent(Event event);
+
     boolean hasHappensAt();
 
     boolean hasNextState();

SimulationCore/src/com/aexiz/daviz/simulation/Execution.java

@@ -29,12 +29,12 @@ public interface Execution {
 
     void setLastEvent(Event lastEvent);
 
+    Event getLastEvent();
+
     Configuration getConfiguration();
 
     void setConfiguration(Configuration configuration);
 
-    void loadFirst();
-
     Simulation getSimulation();
 
     void setSimulation(Simulation simulation);

SimulationCore/src/com/aexiz/daviz/simulation/Network.java

@@ -4,6 +4,9 @@
 import com.aexiz.daviz.simulation.viewpoint.Node;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+import java.util.Map;
+
 public interface Network {
     Node addNode(@NotNull Node process);
 
@@ -17,6 +20,10 @@ public interface Network {
 
     Channel[] getChannels();
 
+    List<Channel> getChannelsFromNode(Node node);
+
+    Map<Node, List<Channel>> makeMapOfChannelsFromNodes();
+
     boolean isWeighted();
 
     boolean isStronglyConnected();

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/event/tInternalEvent.java

@@ -1,4 +1,6 @@
 package com.aexiz.daviz.simulation.algorithm.event;
 
-public interface tInternalEvent {
+import com.aexiz.daviz.simulation.Event;
+
+public interface tInternalEvent extends Event {
 }

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/event/tReceiveEvent.java

@@ -1,4 +1,6 @@
 package com.aexiz.daviz.simulation.algorithm.event;
 
-public interface tReceiveEvent {
+import com.aexiz.daviz.simulation.Event;
+
+public interface tReceiveEvent extends Event {
 }

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/event/tResultEvent.java

@@ -1,4 +1,6 @@
 package com.aexiz.daviz.simulation.algorithm.event;
 
-public interface tResultEvent {
+import com.aexiz.daviz.simulation.Event;
+
+public interface tResultEvent extends Event {
 }

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/event/tSendEvent.java

@@ -1,4 +1,6 @@
 package com.aexiz.daviz.simulation.algorithm.event;
 
-public interface tSendEvent {
+import com.aexiz.daviz.simulation.Event;
+
+public interface tSendEvent extends Event {
 }

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/information/state/AbstractViewpointState.java

@@ -17,4 +17,8 @@ public String toString() {
         Class<? extends Viewpoint> viewpointClass = viewpoint.getClass();
         return state + "<" + viewpointClass + ">";
     }
+
+    public Viewpoint getViewpoint() {
+        return viewpoint;
+    }
 }

SimulationCore/src/com/aexiz/daviz/simulation/algorithm/information/state/UndefinedState.java

@@ -2,6 +2,6 @@
 
 public class UndefinedState extends AbstractState {
     public UndefinedState() {
-        super("Initiator");
+        super("Undefined");
     }
 }