Merge pull request #5 from vovak/performance_test

Performance test

Author: egor-bogomolov

build.gradle

@@ -48,6 +48,11 @@ task processPyExample(type: JavaExec) {
     classpath = sourceSets.main.runtimeClasspath
 }
 
+task performanceTest(type: JavaExec) {
+    main = 'miningtool.performance.PerformanceTest'
+    classpath = sourceSets.main.runtimeClasspath
+}
+
 antlr4 {
     source = file('antlr')
     output = file('src/main/generated/me/vovak/antlr/parser')

src/main/kotlin/miningtool/examples/AllJavaFiles.kt

@@ -9,7 +9,7 @@ import java.io.File
 
 //Retrieve paths from Java files, using a generated parser.
 fun allJavaFiles() {
-    val folder = "./testData"
+    val folder = "./testData/examples/"
 
     val miner = PathMiner(PathRetrievalSettings(5, 5))
     val storage = VocabularyPathStorage()

src/main/kotlin/miningtool/examples/AllJavaFilesGumTree.kt

@@ -9,7 +9,7 @@ import java.io.File
 
 //Retrieve paths from Java files, using a GumTree parser.
 fun allJavaFilesGumTree() {
-    val folder = "./testData"
+    val folder = "./testData/examples/"
 
     val miner = PathMiner(PathRetrievalSettings(5, 5))
     val storage = VocabularyPathStorage()

src/main/kotlin/miningtool/examples/AllJavaMethods.kt

@@ -20,7 +20,7 @@ private fun getCsvFriendlyMethodId(methodInfo: MethodInfo?): String {
 //Retrieve paths from all Java files, using a GumTree parser.
 //GumTreeMethodSplitter is used to extract individual method nodes from the compilation unit tree.
 fun allJavaMethods() {
-    val folder = "./testData"
+    val folder = "./testData/examples/"
 
     val miner = PathMiner(PathRetrievalSettings(5, 5))
 

src/main/kotlin/miningtool/examples/AllPythonFiles.kt

@@ -9,7 +9,7 @@ import java.io.File
 
 
 fun allPythonFiles() {
-    val folder = "./testData"
+    val folder = "./testData/examples/"
 
     val miner = PathMiner(PathRetrievalSettings(5, 5))
     val storage = VocabularyPathStorage()

src/main/kotlin/miningtool/parse/antlr/java/Java8Parser.kt

@@ -12,8 +12,10 @@ import java.io.InputStream
 class Java8Parser : Parser<SimpleNode> {
     override fun parse(content: InputStream): SimpleNode? {
         val lexer = JavaLexer(ANTLRInputStream(content))
+        lexer.removeErrorListeners()
         val tokens = CommonTokenStream(lexer)
         val parser = JavaParser(tokens)
+        parser.removeErrorListeners()
         val context = parser.compilationUnit()
         return convertAntlrTree(context, JavaParser.ruleNames)
     }

src/main/kotlin/miningtool/parse/antlr/python/PythonParser.kt

@@ -12,8 +12,10 @@ import java.io.InputStream
 class PythonParser : Parser<SimpleNode> {
     override fun parse(content: InputStream): SimpleNode? {
         val lexer = Python3Lexer(ANTLRInputStream(content))
+        lexer.removeErrorListeners()
         val tokens = CommonTokenStream(lexer)
         val parser = Python3Parser(tokens)
+        parser.removeErrorListeners()
         val context = parser.file_input()
         return convertAntlrTree(context, Python3Parser.ruleNames)
     }

src/main/kotlin/miningtool/performance/PerformanceTest.kt

@@ -0,0 +1,87 @@
+@file:JvmName("PerformanceTest")
+
+package miningtool.performance
+
+import miningtool.common.Node
+import miningtool.common.Parser
+import miningtool.common.toPathContext
+import miningtool.parse.antlr.java.Java8Parser
+import miningtool.parse.antlr.python.PythonParser
+import miningtool.paths.PathMiner
+import miningtool.paths.PathRetrievalSettings
+import miningtool.paths.storage.VocabularyPathStorage
+import java.io.File
+import java.lang.IllegalStateException
+
+fun <NodeType : Node, LangParser : Parser<NodeType>> langPerformanceTest(language: String,
+                                                                         langSuffix: String,
+                                                                         parser: LangParser,
+                                                                         retrievalSettings: PathRetrievalSettings) {
+    val startTime = System.currentTimeMillis()
+
+    println("Running performance test for $language")
+
+    val folder = "./testData/performanceTest/$langSuffix/"
+    println("Using files in $folder")
+
+    val miner = PathMiner(retrievalSettings)
+    val storage = VocabularyPathStorage()
+
+    var filesNumber = 0L
+    var filesFailed = 0L
+    var locNumber = 0L
+    var parsingElapsedTime = 0L
+    var retrievingElapsedTime = 0L
+    var storingElapsedTime = 0L
+
+    File(folder).walkTopDown().filter { it.path.endsWith(".$langSuffix") }.forEach { file ->
+        try {
+            var currentTime = System.currentTimeMillis()
+            val node = parser.parse(file.inputStream())
+            parsingElapsedTime += System.currentTimeMillis() - currentTime
+            if (node == null) return@forEach
+
+            currentTime = System.currentTimeMillis()
+            val paths = miner.retrievePaths(node)
+            retrievingElapsedTime += System.currentTimeMillis() - currentTime
+
+            currentTime = System.currentTimeMillis()
+            storage.store(paths.map { toPathContext(it) }, entityId = file.path)
+            storingElapsedTime += System.currentTimeMillis() - currentTime
+
+            // If parsing is successful
+            filesNumber++
+            locNumber += file.readLines().size
+        } catch (e: IllegalStateException) {
+            println("Unable to parse ${file.path}")
+            filesFailed++
+        }
+    }
+
+    val currentTime = System.currentTimeMillis()
+    storage.save("out_examples/performanceTest$language")
+    storingElapsedTime += System.currentTimeMillis() - currentTime
+
+    println("Performance test took ${(System.currentTimeMillis() - startTime) / 1000} sec")
+    println("Processed $filesNumber files, $locNumber lines of code")
+    println("Failed to parse $filesFailed files")
+    println()
+    println("Parsing overall time: ${parsingElapsedTime / 1000} sec")
+    println("Parsing speed: ${filesNumber * 1000 / parsingElapsedTime} files/sec, " +
+            "${locNumber * 1000 / parsingElapsedTime} loc/sec")
+    println()
+    println("Path retrieval overall time: ${retrievingElapsedTime / 1000} sec")
+    println("Path retrieval speed: ${filesNumber * 1000 / retrievingElapsedTime} files/sec, " +
+            "${locNumber * 1000 / retrievingElapsedTime} loc/sec")
+    println()
+    println("Storing overall time: ${storingElapsedTime / 1000} sec")
+    println("Storing speed: ${filesNumber * 1000 / storingElapsedTime} files/sec, " +
+            "${locNumber * 1000 / storingElapsedTime} loc/sec")
+    println()
+}
+
+fun main(args: Array<String>) {
+    val retrievalSettings = PathRetrievalSettings(5, 5)
+    langPerformanceTest("Python", "py", PythonParser(), retrievalSettings)
+    langPerformanceTest("Java", "java", Java8Parser(), retrievalSettings)
+}

src/test/kotlin/miningtool/parse/antlr/python/ANTLRPythonParserTest.kt

@@ -10,7 +10,7 @@ class ANTLRPythonParserTest {
     @Test
     fun testNodeIsNotNull() {
         val parser = PythonParser()
-        val file = File("testData/1.py")
+        val file = File("testData/examples/1.py")
 
         val node = parser.parse(FileInputStream(file))
         Assert.assertNotNull("Parse tree for a valid file should not be null", node)

src/test/kotlin/miningtool/parse/java/GumTreeJavaParserTest.kt

@@ -8,7 +8,7 @@ class GumTreeJavaParserTest {
     @Test
     fun testNodeIsNotNull() {
         val parser = GumTreeJavaParser()
-        val file = File("testData/1.java")
+        val file = File("testData/examples/1.java")
 
         val node = parser.parse(FileInputStream(file))
         Assert.assertNotNull("Parse tree for a valid file should not be null", node)