Improve filterDistinctRoots performance

By using a cheap path length comparison we can return faster from within `isAncestorOf` in some cases.
d4rken-org · Nov 28, 2024 · c396768 · c396768
1 parent aa8edec
commit c396768
Show file tree

Hide file tree

Showing 3 changed files with 30 additions and 7 deletions.
diff --git a/app-common-io/src/main/java/eu/darken/sdmse/common/files/APathLookupExtensions.kt b/app-common-io/src/main/java/eu/darken/sdmse/common/files/APathLookupExtensions.kt
@@ -1,5 +1,7 @@
 package eu.darken.sdmse.common.files
 
+import eu.darken.sdmse.common.debug.logging.Logging.Priority.VERBOSE
+import eu.darken.sdmse.common.debug.logging.log
 import kotlinx.coroutines.flow.Flow
 import okio.FileHandle
 
@@ -91,8 +93,14 @@ fun APathLookup<*>.removePrefix(prefix: APath, overlap: Int = 0) =
     lookedUp.removePrefix(prefix, overlap)
 
 fun Collection<APathLookup<*>>.filterDistinctRoots(): Set<APathLookup<*>> {
+    log(VERBOSE) { "Creating lookup map..." }
     val lookupMap = this.associateBy { it.lookedUp }
-    return lookupMap.keys.filterDistinctRoots().map { lookupMap.getValue(it) }.toSet()
+    log(VERBOSE) { "Lookup map created with ${lookupMap.size} entries, now filtering..." }
+    return lookupMap.keys
+        .filterDistinctRoots()
+        .map { lookupMap.getValue(it) }
+        .toSet()
+        .also { log(VERBOSE) { "After filtering we got ${it.size} distinct roots" } }
 }
 
 val APathLookup<*>.extension: String?

diff --git a/app-common-io/src/main/java/eu/darken/sdmse/common/files/local/LocalPathExtensions.kt b/app-common-io/src/main/java/eu/darken/sdmse/common/files/local/LocalPathExtensions.kt
@@ -83,13 +83,14 @@ fun LocalPath.performLookupExtended(
 }
 
 fun LocalPath.isAncestorOf(child: LocalPath): Boolean {
-    val parentPath = this.asFile().absolutePath
-    val childPath = child.asFile().absolutePath
+    val parentPath = this.asFile().path
+    val childPath = child.asFile().path
 
-    return when (parentPath) {
-        childPath -> false
-        File.separator -> childPath.startsWith(parentPath)
-        else -> childPath.startsWith(parentPath + File.separator)
+    return when {
+        parentPath.length >= childPath.length -> false
+        !childPath.startsWith(parentPath) -> false
+        parentPath == File.separator -> true
+        else -> childPath[parentPath.length] == File.separatorChar
     }
 }
 

diff --git a/app-common-io/src/test/java/eu/darken/sdmse/common/files/APathLookupExtensionTest.kt b/app-common-io/src/test/java/eu/darken/sdmse/common/files/APathLookupExtensionTest.kt
@@ -142,4 +142,18 @@ class APathLookupExtensionTest : BaseTest() {
             lookup4
         )
     }
+
+    @Test fun `filterDistinctRoots performance`() {
+        val targets = mutableSetOf<LocalPathLookup>()
+        (1..8000).forEach {
+            LocalPathLookup(
+                lookedUp = LocalPath.build("parentA", "parentB", "file$it"),
+                fileType = FileType.FILE,
+                size = 0,
+                modifiedAt = Instant.EPOCH,
+                target = null,
+            ).run { targets.add(this) }
+        }
+        targets.filterDistinctRoots().size shouldBe 8000
+    }
 }