perf(model-server): skip batching for entries cached by ignite

Author: slisson

model-datastructure/src/commonMain/kotlin/org/modelix/model/async/CachingAsyncStore.kt

@@ -58,7 +58,7 @@ class CachingAsyncStore(val store: IAsyncObjectStore, cacheSize: Int = 100_000)
     }
 
     override fun <T : Any> getIfCached(key: ObjectHash<T>): T? {
-        return runSynchronized(cache) { cache.get(key) as T? }
+        return runSynchronized(cache) { cache.get(key) as T? } ?: store.getIfCached(key)
     }
 
     override fun getAllAsStream(keys: Observable<ObjectHash<*>>): Observable<Pair<ObjectHash<*>, Any?>> {

model-server/src/main/kotlin/org/modelix/model/server/store/IGenericStoreClient.kt

@@ -45,6 +45,7 @@ interface IGenericStoreClient<KeyT> : AutoCloseable {
         val entries = getAll(keys.toSet())
         return keys.map { entries[it] }
     }
+    fun getIfCached(key: KeyT): String?
     fun getAll(keys: Set<KeyT>): Map<KeyT, String?>
     fun getAll(): Map<KeyT, String?>
     fun put(key: KeyT, value: String?, silent: Boolean = false) = putAll(mapOf(key to value))

model-server/src/main/kotlin/org/modelix/model/server/store/IgniteStoreClient.kt

@@ -18,6 +18,7 @@ import mu.KotlinLogging
 import org.apache.ignite.Ignite
 import org.apache.ignite.IgniteCache
 import org.apache.ignite.Ignition
+import org.apache.ignite.cache.CachePeekMode
 import org.apache.ignite.cache.query.ScanQuery
 import org.apache.ignite.lang.IgniteBiPredicate
 import org.apache.ignite.lang.IgniteClosure
@@ -93,6 +94,10 @@ class IgniteStoreClient(jdbcProperties: Properties? = null, private val inmemory
         SqlUtils(dataSource.connection).ensureSchemaInitialization()
     }
 
+    override fun getIfCached(key: ObjectInRepository): String? {
+        return cache.localPeek(key, CachePeekMode.ONHEAP, CachePeekMode.OFFHEAP)
+    }
+
     override fun getAll(keys: Set<ObjectInRepository>): Map<ObjectInRepository, String?> {
         return cache.getAll(keys)
     }

model-server/src/main/kotlin/org/modelix/model/server/store/InMemoryStoreClient.kt

@@ -45,6 +45,10 @@ class InMemoryStoreClient : IsolatingStore {
         return if (transactionValues?.contains(key) == true) transactionValues!![key] else values[key]
     }
 
+    override fun getIfCached(key: ObjectInRepository): String? {
+        return get(key)
+    }
+
     @Synchronized
     override fun getAll(keys: List<ObjectInRepository>): List<String?> {
         return keys.map { get(it) }

model-server/src/main/kotlin/org/modelix/model/server/store/StoreClientAdapter.kt

@@ -42,6 +42,14 @@ abstract class StoreClientAdapter(val client: IsolatingStore) : IStoreClient {
         return keys.map { map[it] }
     }
 
+    override fun getIfCached(key: String): String? {
+        val fromRepository = client.getIfCached(key.withRepoScope())
+        if (fromRepository != null) return fromRepository
+        // Existing databases may have objects stored without information about the repository.
+        // Try to load these legacy entries.
+        return client.getIfCached(ObjectInRepository.global(key))
+    }
+
     override fun getAll(keys: Set<String>): Map<String, String?> {
         val fromRepository = client.getAll(keys.map { it.withRepoScope() }.toSet()).mapKeys { it.key.key }
         if (getRepositoryId() == null) return fromRepository

model-server/src/main/kotlin/org/modelix/model/server/store/StoreClientAsAsyncStore.kt

@@ -44,7 +44,7 @@ class StoreClientAsAsyncStore(val store: IStoreClient) : IAsyncObjectStore {
     }
 
     override fun <T : Any> getIfCached(key: ObjectHash<T>): T? {
-        return null
+        return store.getIfCached(key.hash)?.let { key.deserializer(it) }
     }
 
     override fun <T : Any> get(key: ObjectHash<T>): Maybe<T> {