Improve parallel interface

Signed-off-by: Kyle Corry <[email protected]>

Author: kylecorry31

app/src/main/java/com/kylecorry/trail_sense/shared/andromeda_temp/ParallelCoroutineRunner2.kt

@@ -5,44 +5,70 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 
-class ParallelCoroutineRunner2(maxParallel: Int = 8) {
+object Parallel {
 
-    private val semaphore = Semaphore(maxParallel)
+    fun getProcessorCount(): Int {
+        return Runtime.getRuntime().availableProcessors()
+    }
+
+    private fun getDefaultMaxParallel(): Int {
+        return getProcessorCount().coerceAtLeast(2)
+    }
 
-    suspend fun run(coroutines: List<suspend () -> Any>) = coroutineScope {
-        for (coroutine in coroutines) {
-            launch {
-                semaphore.withPermit { coroutine() }
+    suspend fun forEach(
+        coroutines: List<suspend () -> Any>,
+        maxParallel: Int = getDefaultMaxParallel()
+    ) =
+        coroutineScope {
+            val semaphore = Semaphore(maxParallel)
+            for (coroutine in coroutines) {
+                launch {
+                    semaphore.withPermit { coroutine() }
+                }
             }
         }
-    }
 
-    suspend fun <R> run(items: List<R>, coroutine: suspend (R) -> Unit) {
-        run(items.map { { coroutine(it) } })
+    suspend fun <R> forEach(
+        items: List<R>,
+        maxParallel: Int = getDefaultMaxParallel(),
+        coroutine: suspend (R) -> Unit
+    ) {
+        forEach(items.map { { coroutine(it) } }, maxParallel)
     }
 
-    suspend fun <T> map(coroutines: List<suspend () -> T>): List<T> {
+    suspend fun <T> map(
+        coroutines: List<suspend () -> T>,
+        maxParallel: Int = getDefaultMaxParallel()
+    ): List<T> {
         val items = mutableListOf<Pair<Int, T>>()
         val lock = Any()
 
-        run(coroutines.mapIndexed { index, coroutine ->
+        forEach(coroutines.mapIndexed { index, coroutine ->
             {
                 val item = coroutine()
                 synchronized(lock) {
                     items.add(index to item)
                 }
             }
-        })
+        }, maxParallel)
 
         return items.sortedBy { it.first }.map { it.second }
     }
 
-    suspend fun <T> mapFunctions(functions: List<() -> T>): List<T> {
-        return map(functions.map { { it() } })
+    suspend fun <T> mapFunctions(
+        functions: List<() -> T>,
+        maxParallel: Int = getDefaultMaxParallel()
+    ): List<T> {
+        return map(functions.map { { it() } }, maxParallel)
     }
 
-    suspend fun <R, T> map(items: List<R>, coroutine: suspend (R) -> T): List<T> {
-        return map(items.map { { coroutine(it) } })
+    suspend fun <R, T> map(
+        items: List<R>,
+        maxParallel: Int = getDefaultMaxParallel(),
+        coroutine: suspend (R) -> T
+    ): List<T> {
+        return map(items.map { { coroutine(it) } }, maxParallel)
     }
 
+
 }

app/src/main/java/com/kylecorry/trail_sense/shared/map_layers/MapLayerBackgroundTask.kt

@@ -2,9 +2,8 @@ package com.kylecorry.trail_sense.shared.map_layers
 
 import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.luna.coroutines.CoroutineQueueRunner
-import com.kylecorry.luna.coroutines.ParallelCoroutineRunner
 import com.kylecorry.sol.science.geology.CoordinateBounds
-import com.kylecorry.trail_sense.shared.andromeda_temp.ParallelCoroutineRunner2
+import com.kylecorry.trail_sense.shared.andromeda_temp.Parallel
 import com.kylecorry.trail_sense.shared.andromeda_temp.grow
 import com.kylecorry.trail_sense.shared.device.DeviceSubsystem
 import com.kylecorry.trail_sense.shared.map_layers.tiles.TileMath
@@ -63,8 +62,7 @@ class MapLayerBackgroundTask {
             val taskCopy = synchronized(taskLock) {
                 tasks.toList()
             }
-            val parallel = ParallelCoroutineRunner2()
-            parallel.run(taskCopy.map { { it(bounds, metersPerPixel) } })
+            Parallel.forEach(taskCopy.map { { it(bounds, metersPerPixel) } })
         }
     ) {
 

app/src/main/java/com/kylecorry/trail_sense/shared/map_layers/MapLayerBackgroundTask2.kt

@@ -2,10 +2,9 @@ package com.kylecorry.trail_sense.shared.map_layers
 
 import com.kylecorry.andromeda.core.cache.AppServiceRegistry
 import com.kylecorry.luna.coroutines.CoroutineQueueRunner
-import com.kylecorry.luna.coroutines.ParallelCoroutineRunner
 import com.kylecorry.sol.math.geometry.Rectangle
 import com.kylecorry.sol.science.geology.CoordinateBounds
-import com.kylecorry.trail_sense.shared.andromeda_temp.ParallelCoroutineRunner2
+import com.kylecorry.trail_sense.shared.andromeda_temp.Parallel
 import com.kylecorry.trail_sense.shared.andromeda_temp.grow
 import com.kylecorry.trail_sense.shared.device.DeviceSubsystem
 import com.kylecorry.trail_sense.shared.map_layers.tiles.TileMath
@@ -66,8 +65,7 @@ class MapLayerBackgroundTask2 {
             val taskCopy = synchronized(taskLock) {
                 tasks.toList()
             }
-            val parallel = ParallelCoroutineRunner2()
-            parallel.run(taskCopy.map { { it(viewBounds, bounds, projection) } })
+            Parallel.forEach(taskCopy.map { { it(viewBounds, bounds, projection) } })
         }
     ) {
 

app/src/main/java/com/kylecorry/trail_sense/shared/map_layers/tiles/TileLoader.kt

@@ -10,9 +10,9 @@ import com.kylecorry.andromeda.bitmaps.operations.Conditional
 import com.kylecorry.andromeda.bitmaps.operations.Convert
 import com.kylecorry.andromeda.bitmaps.operations.ReplaceColor
 import com.kylecorry.andromeda.bitmaps.operations.applyOperationsOrNull
-import com.kylecorry.luna.coroutines.ParallelCoroutineRunner
 import com.kylecorry.luna.coroutines.onDefault
 import com.kylecorry.sol.science.geology.CoordinateBounds
+import com.kylecorry.trail_sense.shared.andromeda_temp.Parallel
 import com.kylecorry.trail_sense.tools.photo_maps.infrastructure.tiles.PhotoMapRegionLoader
 import kotlin.math.hypot
 
@@ -80,17 +80,16 @@ class TileLoader {
         }
 
         var hasChanges = false
-        val parallel = ParallelCoroutineRunner()
 
         val middleX = tileSources.keys.map { it.x }.average()
         val middleY = tileSources.keys.map { it.y }.average()
 
         val sortedEntries = tileSources.entries
             .sortedBy { hypot(it.key.x - middleX, it.key.y - middleY) }
 
-        parallel.run(sortedEntries.toList()) { source ->
+        Parallel.forEach(sortedEntries.toList()) { source ->
             if (tileCache.containsKey(source.key) && !alwaysReloadTiles) {
-                return@run
+                return@forEach
             }
 
             val config = if (backgroundColor.alpha != 255) {
@@ -153,7 +152,7 @@ class TileLoader {
             synchronized(lock) {
                 if (clearTileWhenNullResponse || image != null) {
                     val old = tileCache[source.key]
-                    if (image == null){
+                    if (image == null) {
                         tileCache -= source.key
                     } else {
                         tileCache += source.key to listOfNotNull(image)