Merge branch 'release/1.4.0'

analyzer/main.py

@@ -1,5 +1,8 @@
+from ast import literal_eval
 from datetime import datetime
+from distutils.util import strtobool
 from pprint import pprint
+
 import re
 import sys
 
@@ -22,13 +25,16 @@ def chunks(lst, processors):
 
 
 def get_info_execution(info):
-    results = info[1:-1].split(',')
+    results = info[1:-1].split(', ')
     results = [val.strip().split('=') for val in results]
     results = {key: value for [key, value] in results}
-    results['algorithms'] = results['algorithms'].split(';')
-    results['directed'] = bool(results['directed'])
+    results['algorithms'] = literal_eval(
+        results['algorithms'])  # results['algorithms'].split(',')
+    results['directed'] = strtobool(results['directed'])
     results['iterations'] = int(results['iterations'])
     results['vertexSize'] = int(results['vertexSize'])
+    results['putSteals'] = strtobool(results['putSteals'])
+    results['stealTime'] = strtobool(results['stealTime'])
     return results
 
 
@@ -46,24 +52,25 @@ def parse_file(path_file):
         for thread in range(1, processors + 1):
             dict_thread = {}
             pos = idx_threads[thread - 1]
-            algs = {alg: info.index('Algorithm:\t{}'.format(alg), pos, pos + 312)
+            algs = {alg: info.index('Algorithm:\t{}'.format(alg), pos)
                     for alg in results['algorithms']}
             for key in algs:
                 datos = list(filter(lambda x: x != '',
-                                    info[algs[key] + 2:algs[key] + 26]))
-                statistics = info[algs[key] + 27:algs[key] + 33:2] + \
-                    info[algs[key] + 33:algs[key] + 36]
-                statistics = {output[0]: output[1].strip()
+                                    info[algs[key] + 2:algs[key] + 51]))
+                statistics = info[algs[key] + 42:algs[key] + 48:2] + \
+                    info[algs[key] + 48:algs[key] + 51]
+                statistics = {output[0]: float(output[1].strip())
                               for line in statistics if (output := line.split(':'))
                               is not None}
-                datos = [datos[i:i + 4] for i in range(0, len(datos), 4)]
-                datos = {idx: {output[0]: int(output[1].strip())
+                datos = [datos[i:i + 7] for i in range(0, len(datos) - 8, 7)]
+                datos = {idx: {output[0]: float(output[1].strip())
                                for val in line if (output := val.split(':'))
                                is not None}
                          for idx, line in enumerate(datos)}
                 dict_thread[key] = {'datos': datos, 'statistics': statistics}
             execs['thread-{}'.format(thread)] = dict_thread
         results['executions'] = execs
+        pprint(results)
         return results
 
 

config.json

@@ -0,0 +1,30 @@
+{
+  "algorithms": [
+    "CILK",
+    "CHASELEV",
+    "IDEMPOTENT_LIFO",
+    "IDEMPOTENT_FIFO",
+    "IDEMPOTENT_DEQUE",
+    "WS_NC_MULT",
+    "B_WS_NC_MULT"
+  ],
+  "spanningTreeOptions": {
+    "graphType": "TORUS_3D_40",
+    "vertexSize": 100,
+    "stepSpanningType": "COUNTER",
+    "iterations": 5,
+    "directed": true,
+    "stealTime": true
+  },
+  "putSteals": {
+    "operations": 1000000
+  },
+  "putTakes": {
+    "operations": 1000000
+  },
+  "putsTakesSteals": {
+    "workers": 2,
+    "stealers": 1,
+    "operations": 1000000
+  }
+}

pom.xml

@@ -6,7 +6,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>org.mx.unam.imate</groupId>
     <artifactId>concurrentAlgorithms</artifactId>
-    <version>1.4.0-SNAPSHOT</version>
+    <version>1.4.0</version>
     <packaging>jar</packaging>
     <dependencies>
         <dependency>
@@ -39,6 +39,11 @@
             <version>${junit.platform.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.json</groupId>
+            <artifactId>json</artifactId>
+            <version>20200518</version>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

properties.props

@@ -3,4 +3,5 @@ vertexSize: 100
 stepSpanningType: COUNTER
 iterations: 5
 algorithms: CILK;CHASELEV;IDEMPOTENT_LIFO;IDEMPOTENT_FIFO;IDEMPOTENT_DEQUE;WS_NC_MULT;B_WS_NC_MULT
-directed: true
+directed: true
+stealTime: true

src/main/java/org/mx/unam/imate/concurrent/algorithms/experiments/TestBattery.java → src/main/java/org/mx/unam/imate/concurrent/algorithms/experiments/App.java

@@ -33,11 +33,14 @@
 import org.jfree.data.category.DefaultCategoryDataset;
 import org.jfree.data.xy.XYSeries;
 import org.jfree.data.xy.XYSeriesCollection;
+import org.json.JSONArray;
+import org.json.JSONObject;
 import org.mx.unam.imate.concurrent.algorithms.AlgorithmsType;
 import org.mx.unam.imate.concurrent.algorithms.experiments.spanningTree.StatisticsST;
 import org.mx.unam.imate.concurrent.algorithms.experiments.spanningTree.stepSpanningTree.StepSpanningTreeType;
 import org.mx.unam.imate.concurrent.algorithms.utils.Parameters;
 import org.mx.unam.imate.concurrent.algorithms.utils.Result;
+import org.mx.unam.imate.concurrent.algorithms.utils.WorkStealingUtils;
 import org.mx.unam.imate.concurrent.datastructures.graph.Graph;
 import org.mx.unam.imate.concurrent.datastructures.graph.GraphType;
 import org.mx.unam.imate.concurrent.datastructures.graph.GraphUtils;
@@ -48,47 +51,160 @@
  *
  * @author miguel
  */
-public class TestBattery {
+public class App {
 
-    private final GraphType graphType;
-    private final Integer vertexSize;
-    private final StepSpanningTreeType stepType;
-    private final Integer iterations;
+    private static final String VERTEX_SIZE = "vertexSize";
+    private static final String SPANNING_TREE_OPTIONS = "spanningTreeOptions";
+    private static final String GRAPH_TYPE = "graphType";
+    private static final String STEP_SPANNING_TYPE = "stepSpanningType";
+    private static final String ITERATIONS = "iterations";
+    private static final String DIRECTED = "directed";
+    private static final String STEAL_TIME = "stealTime";
+    private static final String PUT_STEALS = "putSteals";
+    private static final String PUT_TAKES = "putTakes";
+    private static final String PUTS_TAKES_STEALS = "putsTakesSteals";
+    private static final String ALGORITHMS = "algorithms";
+
+    private final JSONObject spanningTreeOptions;
+    private final JSONObject putStealsOptions;
+    private final JSONObject putTakesOptions;
     private final List<AlgorithmsType> types;
-    private final boolean directed;
-
-    public TestBattery(GraphType graphType, int vertexSize, StepSpanningTreeType stepType, int iterations, List<AlgorithmsType> types, boolean directed) {
-        this.graphType = graphType;
-        this.vertexSize = vertexSize;
-        this.stepType = stepType;
-        this.iterations = iterations;
-        this.types = types;
-        this.directed = directed;
+    private final boolean putSteals;
+    private final boolean putTakes;
+    private final boolean spanningTree;
+    private final boolean putsTakesSteals;
+    private final JSONObject ptsOptions;
+
+    public App(JSONObject object) {
+        this.spanningTree = object.has(SPANNING_TREE_OPTIONS);
+        this.spanningTreeOptions = getOptionalValueJSONObj(object, SPANNING_TREE_OPTIONS);
+        this.putSteals = object.has(PUT_STEALS);
+        this.putStealsOptions = getOptionalValueJSONObj(object, PUT_STEALS);
+        this.putTakes = object.has(PUT_TAKES);
+        this.putTakesOptions = getOptionalValueJSONObj(object, PUT_TAKES);
+        this.putsTakesSteals = object.has(PUTS_TAKES_STEALS);
+        this.ptsOptions = getOptionalValueJSONObj(object, PUTS_TAKES_STEALS);
+        this.types = processJSONArray(object.getJSONArray(ALGORITHMS));
+    }
+
+    private boolean getOptionalValueBool(JSONObject object, String key) {
+        return object.has(key) ? object.getBoolean(key) : false;
+    }
+
+    private JSONObject getOptionalValueJSONObj(JSONObject object, String key) {
+        return object.has(key) ? object.getJSONObject(key) : new JSONObject();
+    }
+
+    private JSONArray getAlgorithms(List<AlgorithmsType> types) {
+        JSONArray array = new JSONArray();
+        types.forEach((type) -> {
+            array.put(type.name());
+        });
+        return array;
+    }
+
+    private List<AlgorithmsType> processJSONArray(JSONArray array) {
+        List<AlgorithmsType> algs = new ArrayList<>();
+        for (Object object : array) {
+            algs.add(AlgorithmsType.valueOf(object.toString()));
+        }
+        return algs;
     }
 
     public void compareAlgs() {
+        if (putSteals) {
+            String header
+                    = "=====================================\n"
+                    + "= generating experiment puts-steals =\n"
+                    + "=====================================\n";
+            Experiments exp = new Experiments();
+            System.out.println(header);
+            int operations = putStealsOptions.getInt("operations");
+            JSONArray results = exp.putSteals(types, operations);
+            System.out.println(results.toString(2));
+            WorkStealingUtils.saveJsonArrayToFile(results, "putsSteals.json");
+        }
+        if (putTakes) {
+            String header
+                    = "=====================================\n"
+                    + "= generating experiment puts-takes  =\n"
+                    + "=====================================\n";
+            Experiments exp = new Experiments();
+            System.out.println(header);
+            int operations = putTakesOptions.getInt("operations");
+            JSONArray results = exp.putTakes(types, operations);
+            System.out.println(results.toString(2));
+            WorkStealingUtils.saveJsonArrayToFile(results, "putsTakes.json");
+        }
+        if (putsTakesSteals) {
+            String header
+                    = "============================================\n"
+                    + "= generating experiment puts-takes-steals  =\n"
+                    + "============================================\n";
+            Experiments exp = new Experiments();
+            System.out.println(header);
+            int workers = ptsOptions.getInt("workers");
+            int stealers = ptsOptions.getInt("stealers");
+            int operations = ptsOptions.getInt("operations");
+            JSONObject results = exp.putTakesSteals(types, workers, stealers, operations);
+            System.out.println(results.toString(2));
+            WorkStealingUtils.saveJsonObjectToFile(results, "putsTakesSteals.json");
+        }
+        if (spanningTree) {
+            String header
+                    = "=====================================\n"
+                    + "=      comparing ws-algorithms      =\n"
+                    + "=====================================\n";
+            System.out.println(header);
+            compare(spanningTreeOptions);
+        }
+
+    }
+
+    private JSONObject compare(JSONObject stProps) {
+        JSONObject results = new JSONObject();
+        int vertexSize = stProps.getInt(VERTEX_SIZE);
+        GraphType graphType = GraphType.valueOf(stProps.getString(GRAPH_TYPE));
+        boolean directed = stProps.getBoolean(DIRECTED);
+        StepSpanningTreeType stepType = StepSpanningTreeType.valueOf(stProps.getString(STEP_SPANNING_TYPE));
+        boolean stealTime = stProps.getBoolean(STEAL_TIME);
+        int iterations = stProps.getInt(ITERATIONS);
         int processorsNum = Runtime.getRuntime().availableProcessors();
         Map<AlgorithmsType, List<Result>> lists = buildLists();
         XYSeriesCollection medianDataset = new XYSeriesCollection();
         XYSeriesCollection bestDataset = new XYSeriesCollection();
         XYSeriesCollection averageDataset = new XYSeriesCollection();
         Graph graph = GraphUtils.graphType(vertexSize, graphType, directed);
         {
-            System.out.println("Realizando ejecución de calentamiento :D");
+            System.out.println("Performing warm-up execution :D");
             types.forEach((type) -> {
                 Parameters params = new Parameters(graphType, type,
-                        vertexSize, 8, 128, false, 1, stepType, directed);
+                        vertexSize, 8, 128, false, 1, stepType, directed, stealTime);
                 StatisticsST.experiment(graph, params);
             });
         }
+        results.put("processors", processorsNum);
+        results.put("algorithms", getAlgorithms(types));
+        results.put("directed", directed);
+        results.put("graphType", graphType.name());
+        results.put("iterations", iterations);
+        results.put("stealTime", stealTime);
+        results.put("stepSpanningTree", stepType.name());
+        results.put("vertexSize", vertexSize);
         System.out.println(String.format("Processors: %d", processorsNum));
+        JSONObject execs = new JSONObject();
         for (int i = 0; i < processorsNum; i++) {
             System.out.println("Threads: " + (i + 1));
+            JSONObject iter = new JSONObject();
             for (AlgorithmsType type : types) {
+                JSONObject exec = new JSONObject();
                 lists.get(type).add(getResult(new Parameters(graphType, type, vertexSize,
-                        (i + 1), 128, false, iterations, stepType, directed), graph));
+                        (i + 1), 128, false, iterations, stepType, directed, stealTime), graph, exec));
+                iter.put(type.name(), exec);
             }
+            execs.put(String.format("thread-%d", i), iter);
         }
+        results.put("executions", execs);
 
         long chaseLevMedian = lists.get(AlgorithmsType.CHASELEV).get(0).getMedian();
         long chaseLevBest = lists.get(AlgorithmsType.CHASELEV).get(0).getBest();
@@ -106,11 +222,6 @@ public void compareAlgs() {
             averageDataset.addSeries(getAverageSeries(lists.get(type), chaseLevAverage,
                     processorsNum, getAlgName(type)));
         });
-//        lists.entrySet().forEach((entry) -> {
-//            medianDataset.addSeries(getMedianSeries(entry.getValue(), chaseLevMedian, processorsNum, entry.getKey().toString()));
-//            bestDataset.addSeries(getBestSeries(entry.getValue(), chaseLevBest, processorsNum, entry.getKey().toString()));
-//            averageDataset.addSeries(getAverageSeries(entry.getValue(), chaseLevAverage, processorsNum, entry.getKey().toString()));
-//        });
 
         generateSpeedUpChart("SpeedUp comparison (Median) " + graphType
                 + (directed ? " directed" : " undirected"), "Processors", "SpeedUp",
@@ -124,6 +235,9 @@ public void compareAlgs() {
                 + (directed ? " directed" : " undirected"), "Processors", "SpeedUp",
                 "Average-" + graphType + "-" + stepType + "-" + vertexSize,
                 processorsNum, averageDataset, 3.5);
+//        System.out.println(results.toString(2));
+        WorkStealingUtils.saveJsonObjectToFile(results, "experiment-1.json");
+        return results;
     }
 
     private double medianNormalized(long chaseLevMedian, int processorNum, List<Result> results) {
@@ -141,8 +255,8 @@ private double averageNormalized(double chaseLevAverage, int processorNum, List<
         return chaseLevAverage / average;
     }
 
-    private Result getResult(Parameters params, Graph graph) {
-        return StatisticsST.statistics(StatisticsST.experiment(graph, params));
+    private Result getResult(Parameters params, Graph graph, JSONObject results) {
+        return StatisticsST.statistics(StatisticsST.experiment(graph, params), results);
     }
 
     private Map<AlgorithmsType, List<Result>> buildLists() {
@@ -258,7 +372,7 @@ private void generateSpeedUpChart(String title, String xAxisLabel, String yAxisL
         try {
             ChartUtils.saveChartAsJPEG(XYChart, xylineChart, width, height);
         } catch (IOException ex) {
-            Logger.getLogger(TestBattery.class.getName()).log(Level.SEVERE, null, ex);
+            Logger.getLogger(App.class.getName()).log(Level.SEVERE, null, ex);
         }
     }