flatten: use loop and ArrayDeque instead of recursion

examples/jvm-perfs/benchmark.txt

@@ -1,4 +1,6 @@
-Benchmark                         Mode  Cnt   Score    Error  Units
-BenchmarkClass.emptyStart         avgt   10  ≈ 10⁻³           ms/op
-BenchmarkClass.start400           avgt   10   0,272 ±  0,045  ms/op
-BenchmarkClass.start400AndInject  avgt   10   0,265 ±  0,022  ms/op
+Benchmark                         Mode  Cnt    Score    Error  Units
+BenchmarkClass.emptyStart         avgt   10   ≈ 10⁻³           ms/op
+BenchmarkClass.flatten            avgt   10  146.838 ± 15.775  ms/op
+BenchmarkClass.newFlatten         avgt   10    0.880 ±  0.018  ms/op
+BenchmarkClass.start400           avgt   10    0.282 ±  0.005  ms/op
+BenchmarkClass.start400AndInject  avgt   10    0.278 ±  0.004  ms/op

examples/jvm-perfs/build.gradle.kts

@@ -17,7 +17,7 @@ tasks.getByName<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>("compileKotlin"
 
 val jmhVersion = "1.36"
 //TODO get from existing version.gradle file
-val koin_version = "3.5.2-RC1"
+val koin_version = "3.5.3"
 val coroutines_version = "1.7.3"
 
 dependencies {

examples/jvm-perfs/src/main/kotlin/org/koin/benchmark/BenchmarkClass.kt

@@ -33,4 +33,14 @@ open class BenchmarkClass {
         }.koin
         koinScenario(koin)
     }
+
+    @Benchmark
+    fun flatten() {
+        org.koin.core.module.flatten(nestedModules)
+    }
+
+    @Benchmark
+    fun newFlatten() {
+        newFlatten(nestedModules)
+    }
 }

examples/jvm-perfs/src/main/kotlin/org/koin/benchmark/nestedModules.kt

@@ -0,0 +1,99 @@
+package org.koin.benchmark
+
+import org.koin.core.annotation.KoinInternalApi
+import org.koin.core.module.Module
+import org.koin.core.qualifier.qualifier
+import org.koin.dsl.module
+
+private val level0Modules = List(100) {
+    module {}
+}
+
+private val level1Modules = List(100) {
+    val q = qualifier("q-$it")
+    module {
+        includes(level0Modules)
+        single(q) { A1() }
+        single(q) { A2() }
+        single(q) { A3() }
+        single(q) { A4() }
+        single(q) { A5() }
+    }
+}
+
+private val level2Modules = List(100) {
+    val q = qualifier("q-$it")
+    module {
+        includes(level0Modules)
+        includes(level1Modules[it])
+
+        single(q) { A6() }
+        single(q) { A7() }
+        single(q) { A8() }
+        single(q) { A9() }
+        single(q) { A10() }
+    }
+}
+
+private val level3Modules = List(100) {
+    val q = qualifier("q-$it")
+    module {
+        includes(level0Modules)
+        includes(level2Modules[it])
+
+        single(q) { A11() }
+        single(q) { A12() }
+        single(q) { A13() }
+        single(q) { A14() }
+        single(q) { A15() }
+    }
+}
+
+private val level4Modules = List(100) {
+    val q = qualifier("q-$it")
+    module {
+        includes(level0Modules)
+        includes(level3Modules[it])
+
+        single(q) { A16() }
+        single(q) { A17() }
+        single(q) { A18() }
+        single(q) { A19() }
+        single(q) { A20() }
+    }
+}
+
+internal val nestedModules: List<Module> = List(100) {
+    val q = qualifier("q-$it")
+    module {
+        includes(level0Modules)
+        includes(level1Modules)
+        includes(level2Modules)
+        includes(level3Modules)
+        includes(level4Modules)
+
+        single(q) { A16() }
+        single(q) { A17() }
+        single(q) { A18() }
+        single(q) { A19() }
+        single(q) { A20() }
+    }
+}
+
+@OptIn(KoinInternalApi::class)
+internal fun newFlatten(modules: List<Module>): Set<Module> {
+    val flatten = HashSet<Module>()
+    val stack = ArrayDeque<Module>(modules)
+
+    while (stack.isNotEmpty()) {
+        val current = stack.removeLast()
+        flatten.add(current)
+        current.includedModules.forEach {
+            if (it !in flatten) {
+                stack.addLast(it)
+            }
+        }
+    }
+
+    return flatten
+}

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/Module.kt

@@ -235,12 +235,19 @@ operator fun List<Module>.plus(module: Module): List<Module> = this + listOf(mod
  * Run through the module list to flatten all modules & submodules
  */
 @OptIn(KoinInternalApi::class)
-fun flatten(modules: List<Module>): Set<Module> {
-    fun flat(modules: List<Module>, newModules: MutableSet<Module>){
-        modules.forEach{
-            newModules += it
-            flat(it.includedModules,newModules)
+fun flatten(modules: List<Module>): Set<Module> {    
+    val flatten = HashSet<Module>()
+    val stack = ArrayDeque<Module>(modules)
+
+    while (stack.isNotEmpty()) {
+        val current = stack.removeLast()
+        flatten.add(current)
+        current.includedModules.forEach {
+            if (it !in flatten) {
+                stack.addLast(it)
+            }
         }
     }
-    return mutableSetOf<Module>().apply { flat(modules,this) }
+
+    return flatten
 }