improving cache management

tuProlog · May 23, 2020 · 4e1fdcd · 4e1fdcd
1 parent fd0669f
commit 4e1fdcd
Show file tree

Hide file tree

Showing 17 changed files with 128 additions and 124 deletions.
diff --git a/core/src/commonMain/kotlin/it/unibo/tuprolog/utils/IterUtils.kt b/core/src/commonMain/kotlin/it/unibo/tuprolog/utils/IterUtils.kt
@@ -146,4 +146,8 @@ fun <T> Iterable<T>.subsequences(): Sequence<Sequence<T>> {
 
 fun <T> subsequences(vararg items: T): Sequence<Sequence<T>> {
     return sequenceOf(*items).subsequences()
+}
+
+fun <T> Sequence<T>.buffered(): Sequence<T> {
+    return this
 }
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/Cacheable.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/Cacheable.kt
@@ -3,9 +3,27 @@ package it.unibo.tuprolog.collections.rete.custom
 import it.unibo.tuprolog.collections.rete.custom.clause.SituatedIndexedClause
 
 /**Marks a Class as capable of managing a cache of [SituatedIndexedClause].*/
-internal interface Cacheable {
+internal interface Cacheable<T> {
 
-    /**Retrieves the cache of the current level in the indexing tree*/
-    fun getCache(): Sequence<SituatedIndexedClause>
+    /** Retrieves the cache of the current level in the indexing tree */
+    fun getCache(): Sequence<T>
 
+    fun invalidateCache()
+
+    fun <U> invalidateCacheIfNonEmpty(seq: Sequence<U>): Sequence<U> =
+        sequence {
+            val i = seq.iterator()
+
+            if (i.hasNext()) {
+                invalidateCache()
+                yield(i.next())
+            }
+            while (i.hasNext()) {
+                yield(i.next())
+            }
+        }
+
+    fun <U> Sequence<U>.invalidatingCacheIfNonEmpty(): Sequence<U> =
+        invalidateCacheIfNonEmpty(this)
+
 }
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/ReteNode.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/ReteNode.kt
@@ -1,10 +1,11 @@
 package it.unibo.tuprolog.collections.rete.custom
 
 import it.unibo.tuprolog.collections.rete.custom.clause.IndexedClause
+import it.unibo.tuprolog.collections.rete.custom.clause.SituatedIndexedClause
 import it.unibo.tuprolog.core.Clause
 
 /**A data structure to manage the basic behaviour of the [ReteTree]*/
-internal interface ReteNode : Cacheable {
+internal interface ReteNode : Cacheable<SituatedIndexedClause> {
 
     /**Reads all the clauses matching the given [Clause]*/
     fun get(clause: Clause): Sequence<Clause>

diff --git a/.../commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/AbstractIndexingLeaf.kt b/.../commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/AbstractIndexingLeaf.kt
@@ -0,0 +1,9 @@
+package it.unibo.tuprolog.collections.rete.custom.leaf
+
+import it.unibo.tuprolog.collections.rete.custom.IndexingLeaf
+
+internal abstract class AbstractIndexingLeaf : IndexingLeaf {
+    override fun invalidateCache() {
+        /* do nothing */
+    }
+}
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/AtomIndex.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/AtomIndex.kt
@@ -16,7 +16,7 @@ import it.unibo.tuprolog.utils.dequeOf
 internal class AtomIndex(
     private val ordered: Boolean,
     private val nestingLevel: Int
-) : IndexingLeaf, Retractable {
+) : AbstractIndexingLeaf(), Retractable {
 
     private val index: MutableMap<Atom, MutableList<SituatedIndexedClause>> = mutableMapOf()
 

diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/CompoundIndex.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/CompoundIndex.kt
@@ -60,15 +60,9 @@ internal class CompoundIndex(
 
     override fun retractAll(clause: Clause): Sequence<Clause> =
         if (ordered) {
-            retractAllOrdered(clause).let {
-                invalidCache(it)
-                it
-            }
+            retractAllOrdered(clause).invalidatingCacheIfNonEmpty()
         } else {
-            retractAllUnordered(clause).let {
-                invalidCache(it)
-                it
-            }
+            retractAllUnordered(clause).invalidatingCacheIfNonEmpty()
         }
 
     override fun getCache(): Sequence<SituatedIndexedClause> =
@@ -131,18 +125,12 @@ internal class CompoundIndex(
         if (clause.isGlobal()) {
             Utils.merge(
                 functors.values.map {
-                    it.retractAllIndexed(clause).let { res ->
-                        invalidCache(res)
-                        res
-                    }
+                    it.retractAllIndexed(clause).invalidatingCacheIfNonEmpty()
                 }
             )
         } else {
             functors[clause.nestedFunctor()]
-                ?.retractAllIndexed(clause)?.let {
-                    invalidCache(it)
-                    it
-                }
+                ?.retractAllIndexed(clause)?.invalidatingCacheIfNonEmpty()
                 ?: emptySequence()
         }
 
@@ -170,10 +158,8 @@ internal class CompoundIndex(
     private fun Clause.isGlobal(): Boolean =
         this.head!!.nestedFirstArgument(nestingLevel) is Var
 
-    private fun invalidCache(result: Sequence<*>) {
-        if (result.any()) {
-            theoryCache.invalidate()
-        }
+    override fun invalidateCache() {
+        theoryCache.invalidate()
     }
 
     private fun regenerateCache(): MutableList<SituatedIndexedClause> =

diff --git a/...ry/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/DirectiveIndex.kt b/...ry/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/DirectiveIndex.kt
@@ -62,4 +62,10 @@ internal class DirectiveIndex(private val ordered: Boolean) : TopLevelReteNode {
             })
         }
 
+    override fun invalidateCache() {
+        /* do nothing */
+    }
+
+
+
 }
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/NumericIndex.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/NumericIndex.kt
@@ -16,7 +16,7 @@ import it.unibo.tuprolog.utils.dequeOf
 internal class NumericIndex(
     private val ordered: Boolean,
     private val nestingLevel: Int
-) : IndexingLeaf, Retractable {
+) : AbstractIndexingLeaf(), Retractable {
 
     private val index: MutableMap<Numeric, MutableList<SituatedIndexedClause>> = mutableMapOf()
 

diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/VariableIndex.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/leaf/VariableIndex.kt
@@ -11,7 +11,7 @@ import it.unibo.tuprolog.utils.dequeOf
 
 internal class VariableIndex(
     private val ordered: Boolean
-) : IndexingLeaf, Retractable {
+) : AbstractIndexingLeaf(), Retractable {
 
     private val variables: MutableList<SituatedIndexedClause> = dequeOf()
 

diff --git a/...ry/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityIndexing.kt b/...ry/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityIndexing.kt
@@ -0,0 +1,6 @@
+package it.unibo.tuprolog.collections.rete.custom.nodes
+
+import it.unibo.tuprolog.collections.rete.custom.IndexingNode
+import it.unibo.tuprolog.collections.rete.custom.ReteNode
+
+internal interface ArityIndexing : ReteNode, IndexingNode
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityNode.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityNode.kt
@@ -1,6 +1,9 @@
 package it.unibo.tuprolog.collections.rete.custom.nodes
 
-import it.unibo.tuprolog.collections.rete.custom.*
+import it.unibo.tuprolog.collections.rete.custom.IndexingLeaf
+import it.unibo.tuprolog.collections.rete.custom.ReteNode
+import it.unibo.tuprolog.collections.rete.custom.Retractable
+import it.unibo.tuprolog.collections.rete.custom.Utils
 import it.unibo.tuprolog.collections.rete.custom.Utils.nestedFirstArgument
 import it.unibo.tuprolog.collections.rete.custom.clause.IndexedClause
 import it.unibo.tuprolog.collections.rete.custom.clause.SituatedIndexedClause
@@ -14,10 +17,6 @@ import it.unibo.tuprolog.utils.Cached
 import it.unibo.tuprolog.utils.addFirst
 import it.unibo.tuprolog.utils.dequeOf
 
-internal interface ArityRete : ReteNode, TopLevelReteNode
-
-internal interface ArityIndexing : ReteNode, IndexingNode
-
 internal sealed class ArityNode : ReteNode {
 
     internal open class FamilyArityReteNode(
@@ -79,15 +78,9 @@ internal sealed class ArityNode : ReteNode {
 
         override fun retractAll(clause: Clause): Sequence<Clause> =
             if (ordered) {
-                retractAllOrdered(clause).let {
-                    invalidCache(it)
-                    it
-                }
+                retractAllOrdered(clause).invalidatingCacheIfNonEmpty()
             } else {
-                retractAllUnordered(clause).let {
-                    invalidCache(it)
-                    it
-                }
+                retractAllUnordered(clause).invalidatingCacheIfNonEmpty()
             }
 
         override fun getCache(): Sequence<SituatedIndexedClause> =
@@ -267,10 +260,8 @@ internal sealed class ArityNode : ReteNode {
                 )
             }
 
-        protected fun invalidCache(result: Sequence<*>) {
-            if (result.any()) {
-                theoryCache.invalidate()
-            }
+        override fun invalidateCache() {
+            theoryCache.invalidate()
         }
 
         private fun regenerateCache(): MutableList<SituatedIndexedClause> =
@@ -325,15 +316,9 @@ internal sealed class ArityNode : ReteNode {
 
         override fun retractAllIndexed(clause: Clause): Sequence<SituatedIndexedClause> =
             if (ordered) {
-                retractAllOrderedIndexed(clause).let {
-                    invalidCache(it)
-                    it
-                }
+                retractAllOrderedIndexed(clause).invalidatingCacheIfNonEmpty()
             } else {
-                retractAllUnorderedIndexed(clause).let {
-                    invalidCache(it)
-                    it
-                }
+                retractAllUnorderedIndexed(clause).invalidatingCacheIfNonEmpty()
             }
 
         override fun extractGlobalIndexedSequence(clause: Clause): Sequence<SituatedIndexedClause> {
@@ -399,6 +384,10 @@ internal sealed class ArityNode : ReteNode {
             return atoms.asSequence()
         }
 
+        override fun invalidateCache() {
+            /* do nothing */
+        }
+
         override fun retractIndexed(indexed: SituatedIndexedClause) {
             atoms.remove(indexed)
         }

diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityRete.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/ArityRete.kt
@@ -0,0 +1,6 @@
+package it.unibo.tuprolog.collections.rete.custom.nodes
+
+import it.unibo.tuprolog.collections.rete.custom.ReteNode
+import it.unibo.tuprolog.collections.rete.custom.TopLevelReteNode
+
+internal interface ArityRete : ReteNode, TopLevelReteNode
diff --git a/.../src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorIndexing.kt b/.../src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorIndexing.kt
@@ -0,0 +1,7 @@
+package it.unibo.tuprolog.collections.rete.custom.nodes
+
+import it.unibo.tuprolog.collections.rete.custom.IndexingNode
+import it.unibo.tuprolog.collections.rete.custom.ReteNode
+
+internal interface FunctorIndexing : ReteNode,
+    IndexingNode
diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorNode.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorNode.kt
@@ -1,6 +1,5 @@
 package it.unibo.tuprolog.collections.rete.custom.nodes
 
-import it.unibo.tuprolog.collections.rete.custom.IndexingNode
 import it.unibo.tuprolog.collections.rete.custom.ReteNode
 import it.unibo.tuprolog.collections.rete.custom.TopLevelReteNode
 import it.unibo.tuprolog.collections.rete.custom.Utils
@@ -12,12 +11,9 @@ import it.unibo.tuprolog.core.Clause
 import it.unibo.tuprolog.core.Var
 import it.unibo.tuprolog.unify.Unificator.Companion.matches
 import it.unibo.tuprolog.utils.Cached
+import it.unibo.tuprolog.utils.buffered
 import it.unibo.tuprolog.utils.dequeOf
 
-internal interface FunctorRete : ReteNode, TopLevelReteNode
-
-internal interface FunctorIndexing : ReteNode, IndexingNode
-
 internal sealed class FunctorNode : ReteNode {
 
     internal class TopLevelFunctorReteNode(
@@ -40,16 +36,12 @@ internal sealed class FunctorNode : ReteNode {
         }
 
         override fun retractFirst(clause: Clause): Sequence<Clause> =
-            selectArity(clause)?.retractFirst(clause)?.let {
-                invalidCache(it)
-                it
-            } ?: emptySequence()
+            selectArity(clause)?.retractFirst(clause)?.invalidatingCacheIfNonEmpty()
+                ?: emptySequence()
 
         override fun retractAll(clause: Clause): Sequence<Clause> =
-            selectArity(clause)?.retractAll(clause)?.let {
-                invalidCache(it)
-                it
-            } ?: emptySequence()
+            selectArity(clause)?.retractAll(clause)?.invalidatingCacheIfNonEmpty()
+                ?: emptySequence()
 
         override fun getCache(): Sequence<SituatedIndexedClause> =
             theoryCache.value.asSequence()
@@ -70,10 +62,8 @@ internal sealed class FunctorNode : ReteNode {
             }.run { op(clause) }
         }
 
-        private fun invalidCache(result: Sequence<*>) {
-            if (result.any()) {
-                theoryCache.invalidate()
-            }
+        override fun invalidateCache() {
+            theoryCache.invalidate()
         }
 
         private fun regenerateCache(): MutableList<SituatedIndexedClause> =
@@ -118,10 +108,8 @@ internal sealed class FunctorNode : ReteNode {
         }
 
         override fun retractAll(clause: Clause): Sequence<Clause> =
-            arities[clause.nestedArity()]?.retractAll(clause)?.let {
-                invalidCache(it)
-                it
-            } ?: emptySequence()
+            arities[clause.nestedArity()]?.retractAll(clause)?.invalidatingCacheIfNonEmpty()
+                ?: emptySequence()
 
         override fun getCache(): Sequence<SituatedIndexedClause> =
             theoryCache.value.asSequence()
@@ -150,21 +138,17 @@ internal sealed class FunctorNode : ReteNode {
 
         override fun retractAllIndexed(clause: Clause): Sequence<SituatedIndexedClause> =
             if (clause.isGlobal()) {
-                val partialResult = Utils.merge(
+                Utils.merge(
                     arities.values.map {
                         it.extractGlobalIndexedSequence(clause)
-                    }
-                ).toList()
-                val filtered = partialResult.filter { it.innerClause matches clause }
-                filtered.asSequence().forEach { it.removeFromIndex() }
-                invalidCache(filtered.asSequence())
-                filtered.asSequence()
+                    })
+                    .filter { it.innerClause matches clause }
+                    .map { it.removeFromIndex(); it }
+                    .buffered()
             }
             else {
-                arities[clause.nestedArity()]?.retractAllIndexed(clause)?.let {
-                    invalidCache(it)
-                    it
-                } ?: emptySequence()
+                arities[clause.nestedArity()]?.retractAllIndexed(clause)?.invalidatingCacheIfNonEmpty()
+                    ?: emptySequence()
             }
 
         override fun extractGlobalIndexedSequence(clause: Clause): Sequence<SituatedIndexedClause> {
@@ -191,10 +175,8 @@ internal sealed class FunctorNode : ReteNode {
         private fun IndexedClause.nestedArity(): Int =
             this.innerClause.head!!.arityOfNestedFirstArgument(nestingLevel)
 
-        private fun invalidCache(result: Sequence<*>) {
-            if (result.any()) {
-                theoryCache.invalidate()
-            }
+        override fun invalidateCache() {
+            theoryCache.invalidate()
         }
 
         private fun regenerateCache(): MutableList<SituatedIndexedClause> =

diff --git a/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorRete.kt b/theory/src/commonMain/kotlin/it/unibo/tuprolog/collections/rete/custom/nodes/FunctorRete.kt
@@ -0,0 +1,7 @@
+package it.unibo.tuprolog.collections.rete.custom.nodes
+
+import it.unibo.tuprolog.collections.rete.custom.ReteNode
+import it.unibo.tuprolog.collections.rete.custom.TopLevelReteNode
+
+internal interface FunctorRete : ReteNode,
+    TopLevelReteNode
-Original file line number
+Diff line change
@@ Expand Up @@
                 })
             }
+        override fun invalidateCache() {
+            /* do nothing */
+        }
     }