Performance testing

app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt

@@ -4,6 +4,7 @@ import net.pokeranalytics.android.calculus.Stat.*
 import net.pokeranalytics.android.model.realm.Session
 import net.pokeranalytics.android.model.realm.SessionSet
 import timber.log.Timber
+import java.util.*
 
 /**
  * The class performing stats computation
@@ -69,6 +70,7 @@ class Calculator {
 
 			val computedResults = mutableListOf<ComputedResults>()
 			groups.forEach { group ->
+				val s = Date()
 				// Computes actual sessionGroup stats
 				val results: ComputedResults = Calculator.compute(group, options = options)
 
@@ -82,6 +84,11 @@ class Calculator {
 
 				results.finalize(options) // later treatment, such as evolution values sorting
 				computedResults.add(results)
+
+				val e = Date()
+				val duration = (e.time - s.time) / 1000.0
+				Timber.d(">>> group ${group.name} in ${duration} seconds")
+
 			}
 
 			return computedResults

app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt

@@ -109,6 +109,26 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
     private fun launchStatComputation() {
 
+//	    Thread() {
+////		    var results = listOf<ComputedResults>()
+//		    val s = Date()
+//		    Timber.d(">>> start...")
+//
+//		    val results = createSessionGroupsAndStartCompute()
+//
+//		    val e = Date()
+//		    val duration = (e.time - s.time) / 1000.0
+//		    Timber.d(">>> ended in ${duration} seconds")
+//
+//
+//		    val mainHandler = Handler(Looper.getMainLooper())
+//		    val runnable = Runnable {
+//			    showResults(results)
+//		    }
+//		    mainHandler.post(runnable)
+//
+//	    }.start()
+
 	    GlobalScope.launch(coroutineContext) {
 
 		    var results = listOf<ComputedResults>()
@@ -129,16 +149,24 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
     }
 
-    suspend private fun createSessionGroupsAndStartCompute() : List<ComputedResults> {
+	private fun createSessionGroupsAndStartCompute() : List<ComputedResults> {
 
         val cgSessions = mutableListOf<Session>()
         val tSessions = mutableListOf<Session>()
 
+		val s = Date()
+
 	    val realm = Realm.getDefaultInstance()
 	    val allSessions = realm.where(Session::class.java).isNotNull("endDate").findAll()
+		Timber.d(">>>>> number of sessions to compute = ${allSessions.size}")
+
+		val sessionsList = allSessions.toList()
 
-        Timber.d(">>>>> number of sessions to compute = ${allSessions.size}")
+		val e = Date()
-	    allSessions.forEach { session ->
+		val duration = (e.time - s.time) / 1000.0
+		Timber.d(">>> filtering in ${duration} seconds")
+
+		sessionsList.forEach { session ->
             if (session.isCashGame()) {
                 cgSessions.add(session)
             } else {
@@ -147,12 +175,14 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
         }
 
         val allStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NUMBER_OF_SETS, Stat.AVERAGE_DURATION, Stat.DURATION)
-        val allSessionGroup = SessionGroup(getString(R.string.all), allSessions, allStats)
+        val allSessionGroup = SessionGroup(getString(R.string.all), sessionsList, allStats)
         val cgStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.NET_BB_PER_100_HANDS, Stat.HOURLY_RATE_BB, Stat.AVERAGE, Stat.STANDARD_DEVIATION_HOURLY, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
         val cgSessionGroup = SessionGroup(getString(R.string.cash_game), cgSessions, cgStats)
         val tStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
         val tSessionGroup = SessionGroup(getString(R.string.tournament), tSessions, tStats)
 
+
+
         Timber.d(">>>>> Start computations...")
 
         return Calculator.computeGroups(listOf(allSessionGroup, cgSessionGroup, tSessionGroup), Calculator.Options())