Updated CLI and Added InMemory graph benchmark

Author: vkutuev

pom.xml

@@ -184,7 +184,7 @@
                 <configuration>
                     <includeSystemScope>true</includeSystemScope>
                     <addResources>true</addResources>
-                    <mainClass>benchmark.Neo4jBenchmark</mainClass>
+                    <mainClass>benchmark.GraphBenchmark</mainClass>
                 </configuration>
                 <executions>
                     <execution>

src/benchmark/BenchmarkGraphInMemory.java

@@ -0,0 +1,57 @@
+package benchmark;
+
+import iguana.utils.input.Edge;
+import iguana.utils.input.GraphInput;
+import iguana.utils.input.InMemGraphInput;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.*;
+
+public class BenchmarkGraphInMemory extends BenchmarkGraphStorage {
+
+    private List<Integer> finalVertices = null;
+    private final List<List<Edge>> adjacencyList = new ArrayList<>();
+
+    @Override
+    public void loadGraph(String path) throws IOException {
+        try (var lines = Files.lines(Paths.get(path + File.separator + "nodes.csv"))) {
+            finalVertices = lines.skip(1).map(Integer::parseInt).collect(Collectors.toList());
+        }
+        try (var lines = Files.lines(Paths.get(path + File.separator + "edges.csv"))) {
+            var graph = lines
+                    .skip(1)
+                    .map(it -> it.split(" "))
+                    .flatMap(it -> Stream.of(it, new String[]{it[2], it[1] + "_r", it[0]}))
+                    .collect(
+                            groupingBy(e -> Integer.parseInt(e[0]),
+                                    mapping(e -> new Edge(e[1], Integer.parseInt(e[2])), toList()))
+                    );
+            int nodesCount = finalVertices.size();
+            for (var i = 0; i < nodesCount; i++) {
+                adjacencyList.add(graph.getOrDefault(i, new ArrayList<>()));
+            }
+        }
+    }
+
+    @Override
+    public GraphInput getGraphInput(Stream<Integer> startVertices) {
+        return new InMemGraphInput(adjacencyList, startVertices, finalVertices);
+    }
+
+    @Override
+    protected void close() {
+    }
+
+    @Override
+    public String toString() {
+        return "INMEM";
+    }
+}

src/benchmark/Neo4jBenchmark.java src/benchmark/BenchmarkGraphNeo4j.javasrc/benchmark/Neo4jBenchmark.java renamed to src/benchmark/BenchmarkGraphNeo4j.java

@@ -5,7 +5,8 @@
 import apoc.export.csv.ImportCsv;
 import apoc.help.Help;
 import apoc.periodic.Periodic;
-import org.iguana.grammar.Grammar;
+import iguana.utils.input.GraphInput;
+import iguana.utils.input.Neo4jBenchmarkInput;
 import org.neo4j.configuration.GraphDatabaseSettings;
 import org.neo4j.configuration.connectors.BoltConnector;
 import org.neo4j.dbms.api.DatabaseManagementService;
@@ -19,61 +20,22 @@
 import org.neo4j.kernel.api.procedure.GlobalProcedures;
 import org.neo4j.kernel.internal.GraphDatabaseAPI;
 
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.List;
 import java.util.function.BiFunction;
+import java.util.stream.Stream;
 
 import static java.util.Arrays.asList;
 import static org.neo4j.configuration.GraphDatabaseSettings.DEFAULT_DATABASE_NAME;
 
-public abstract class Neo4jBenchmark {
-
-    protected static String RESULTS_DIR = "results";
-
-    // args[0] - benchmarkType
-    // args[1] - nodeNumber
-    // args[2] - number of warm up iteration
-    // args[3] - total number of iterations
-    // args[4] - path to dataset (graph)
-    // args[5] - path to grammar
-    // args[6] - dataset name = name of file with results
-    public static void main(String[] args) throws IOException {
-        Neo4jBenchmark benchmark = benchmarkByType(args[0], Integer.parseInt(args[1]));
-        benchmark.loadGraph(args[4]);
-        benchmark.loadGrammar(args[5]);
-        benchmark.benchmark(parseSettings(new String[]{args[2], args[3], args[6]}));
-        benchmark.removeData();
-        benchmark.managementService.shutdown();
-    }
-    private static Neo4jBenchmark benchmarkByType(String type, int nodesCount) {
-        return switch (type) {
-            // AP - All Pairs; MS - Multiple Sources
-            case "REACHABILITY_AP" -> new ReachabilityBenchmark(nodesCount);
-//            case "REACHABILITY_MS" -> new ReachabilityBenchmark();
-            case "PATH_AP" -> new PathBenchmark(nodesCount);
-//            case "PATH_MS" -> new PathBenchmark();
-            default -> throw new IllegalArgumentException("Illegal benchmark type");
-        };
-    }
+public class BenchmarkGraphNeo4j extends BenchmarkGraphStorage {
 
-    /**
-     * @param args array contains string params:
-     *             args[0] - warmUpIterations
-     *             args[1] - measurementsIterations
-     *             args[2] - datasetName
-     * @return {@link BenchmarkSettings} instance
-     */
-    private static BenchmarkSettings parseSettings(String[] args) {
-        return new BenchmarkSettings(
-                Integer.parseInt(args[0]),
-                Integer.parseInt(args[1]),
-                args[2]);
-    }
+    private int nodesCount;
+
+    BenchmarkGraphNeo4j() {
 
-    Neo4jBenchmark(int nodesCount) {
-        this.nodesCount = nodesCount;
     }
 
     private final BiFunction<Relationship, Direction, String> relationship2Label =
@@ -86,9 +48,8 @@ private static BenchmarkSettings parseSettings(String[] args) {
     private final File databaseDirectory = new File("target/neo4j-hello-db");
     private GraphDatabaseService graphDb;
     private DatabaseManagementService managementService;
-    private Grammar grammar;
-    private final int nodesCount;
-    public void registerProcedure(GraphDatabaseService graphDb, List<Class<?>> procedures) {
+
+    private void registerProcedure(GraphDatabaseService graphDb, List<Class<?>> procedures) {
         GlobalProcedures globalProcedures = ((GraphDatabaseAPI) graphDb).getDependencyResolver().resolveDependency(GlobalProcedures.class);
         for (Class<?> procedure : procedures) {
             try {
@@ -101,7 +62,15 @@ public void registerProcedure(GraphDatabaseService graphDb, List<Class<?>> proce
         }
     }
 
-    private void loadGraph(String pathToDataset) throws IOException {
+    private Neo4jBenchmarkInput graphInput = null;
+
+    @Override
+    public void loadGraph(String path) throws IOException {
+
+        try (var lines = Files.lines(Paths.get(path + File.separatorChar + "nodes.csv"))) {
+            nodesCount = (int) lines.count();
+        }
+
         FileUtils.deleteRecursively(databaseDirectory);
         managementService =
                 new DatabaseManagementServiceBuilder(databaseDirectory)
@@ -124,50 +93,45 @@ private void loadGraph(String pathToDataset) throws IOException {
                 Periodic.class
         ));
 
+        String neo4jPath = new File(path).getAbsolutePath();
         try (Transaction tx = graphDb.beginTx()) {
             tx.execute("CALL apoc.import.csv(" +
-                    "[{fileName: 'FILE:///" + pathToDataset + "nodes.csv', labels: ['Node']}], " +
-                    "[{fileName: 'FILE:///" + pathToDataset + "edges.csv'}], " +
+                    "[{fileName: 'FILE:///" + neo4jPath + File.separator + "nodes.csv', labels: ['Node']}], " +
+                    "[{fileName: 'FILE:///" + neo4jPath + File.separator + "edges.csv'}], " +
                     "{delimiter: ' ', stringIds: false}" +
                     ")");
             tx.commit();
         }
         System.out.println("Graph loaded");
     }
 
-    private void loadGrammar(String pathToGrammar) {
-        try {
-            grammar = Grammar.load(pathToGrammar, "json");
-        } catch (FileNotFoundException e) {
-            throw new RuntimeException("No grammar file is present");
-        }
+    @Override
+    public GraphInput getGraphInput(Stream<Integer> startVertices) {
+        graphInput = new Neo4jBenchmarkInput(graphDb, relationship2Label, startVertices, nodesCount);
+        return graphInput;
     }
 
-    protected abstract void benchmark(BenchmarkSettings settings) throws IOException;
+    @Override
+    protected void onIterationFinish() {
+        graphInput.close();
+        graphInput = null;
+    }
 
-    private void removeData() {
+    @Override
+    protected void close() {
         try (Transaction tx = graphDb.beginTx()) {
             tx.getAllNodes().forEach(node -> {
                 node.getRelationships().forEach(Relationship::delete);
                 node.delete();
             });
             tx.commit();
         }
+        managementService.shutdown();
     }
 
-    protected BiFunction<Relationship, Direction, String> getRelationship2Label() {
-        return relationship2Label;
-    }
-
-    protected GraphDatabaseService getGraphDb() {
-        return graphDb;
-    }
-
-    protected Grammar getGrammar() {
-        return grammar;
+    @Override
+    public String toString() {
+        return "NEO4J";
     }
 
-    protected int getNodesCount() {
-        return nodesCount;
-    }
 }

src/benchmark/BenchmarkGraphStorage.java

@@ -0,0 +1,29 @@
+package benchmark;
+
+import iguana.utils.input.GraphInput;
+
+import java.io.IOException;
+import java.util.stream.Stream;
+
+public abstract class BenchmarkGraphStorage {
+
+    public static BenchmarkGraphStorage createBenchmarkStorage(GraphStorage storageType) {
+        return switch (storageType) {
+            case NEO4J -> new BenchmarkGraphNeo4j();
+            case IN_MEMORY -> new BenchmarkGraphInMemory();
+        };
+    }
+
+    public abstract void loadGraph(String path) throws IOException;
+
+    public abstract GraphInput getGraphInput(Stream<Integer> startVertices);
+
+    protected void onIterationStart() {
+    }
+
+    protected void onIterationFinish() {
+    }
+
+    protected abstract void close();
+
+}

src/benchmark/BenchmarkProblem.java

@@ -0,0 +1,18 @@
+package benchmark;
+
+import iguana.utils.input.GraphInput;
+import org.iguana.parser.IguanaParser;
+
+public abstract class BenchmarkProblem {
+
+    public static BenchmarkProblem createBenchmarkProblem(Problem problem) {
+        return switch (problem) {
+            case REACHABILITY -> new BenchmarkProblemReachability();
+            case ALL_PATHS -> new BenchmarkProblemAllPaths();
+        };
+    }
+
+    public abstract void runAlgo(IguanaParser parser, GraphInput input);
+
+    public abstract long getResult();
+}

src/benchmark/BenchmarkProblemAllPaths.java

@@ -0,0 +1,30 @@
+package benchmark;
+
+import iguana.utils.input.GraphInput;
+import org.iguana.parser.IguanaParser;
+import org.iguana.parser.Pair;
+import org.iguana.parser.ParseOptions;
+import org.iguana.sppf.NonterminalNode;
+
+import java.util.Map;
+import java.util.stream.Stream;
+
+public class BenchmarkProblemAllPaths extends BenchmarkProblem {
+
+    private Map<Pair, NonterminalNode> parseResults = null;
+    @Override
+    public void runAlgo(IguanaParser parser, GraphInput input) {
+        parseResults = parser.getSPPF(input);
+    }
+
+    @Override
+    public long getResult() {
+        return parseResults.size();
+    }
+
+    @Override
+    public String toString() {
+        return "SPPF";
+    }
+
+}

src/benchmark/BenchmarkProblemReachability.java

@@ -0,0 +1,33 @@
+package benchmark;
+
+import iguana.utils.input.GraphInput;
+import org.iguana.parser.IguanaParser;
+import org.iguana.parser.Pair;
+import org.iguana.parser.ParseOptions;
+
+import java.util.stream.Stream;
+
+public class BenchmarkProblemReachability extends BenchmarkProblem {
+
+    private Stream<Pair> parseResults = null;
+
+    @Override
+    public void runAlgo(IguanaParser parser, GraphInput input) {
+        parseResults = parser.getReachabilities(input,
+                new ParseOptions
+                        .Builder()
+                        .setAmbiguous(false)
+                        .build());
+    }
+
+    @Override
+    public long getResult() {
+        return parseResults.count();
+    }
+
+    @Override
+    public String toString() {
+        return "REACHABILITY";
+    }
+
+}

src/benchmark/BenchmarkScenario.java

@@ -0,0 +1,18 @@
+package benchmark;
+
+import java.util.List;
+
+public abstract class BenchmarkScenario {
+
+    public static BenchmarkScenario createBenchmarkScenario(BenchmarkSettings.ScenarioSettings scenario) {
+        return switch (scenario.getScenario()) {
+            case ALL_PAIRS -> new BenchmarkScenarioAllPairs(scenario.getNodesCount());
+            case MULTIPLE_SOURCES -> new BenchmarkScenarioMultipleSources(scenario.getPath());
+        };
+    }
+
+    public abstract String getCsvHeader();
+    public abstract String getCsvRecord(int chunkIndex, double stepPrepareTime, double stepRunTime, long result);
+    public abstract List<List<Integer>> getStartVerticesChunks();
+
+}