perf: remove some promises overhead

Author: Julien-R44

benchmarks/README.md

@@ -46,16 +46,16 @@ And, maybe not super-fair because `cache-manager` does not support it, but here
 ┌─────────┬──────────────────────────────────┬─────────────────────┬─────────────────────┬────────────────────────┬────────────────────────┬─────────┐
 │ (index) │ Task name                        │ Latency avg (ns)    │ Latency med (ns)    │ Throughput avg (ops/s) │ Throughput med (ops/s) │ Samples │
 ├─────────┼──────────────────────────────────┼─────────────────────┼─────────────────────┼────────────────────────┼────────────────────────┼─────────┤
-│ 0       │ 'L1 GetOrSet - BentoCache'       │ '9610.3 ± 98.26%'   │ '1109.0 ± 29.00'    │ '879036 ± 0.05%'       │ '901713 ± 22979'       │ 143980  │
-│ 1       │ 'L1 GetOrSet - CacheManager'     │ '906687 ± 110.96%'  │ '172470 ± 1785.00'  │ '5601 ± 0.56%'         │ '5798 ± 61'            │ 1103    │
-│ 2       │ 'L2 GetOrSet - BentoCache'       │ '2891294 ± 111.70%' │ '550103 ± 21732.50' │ '1770 ± 1.18%'         │ '1818 ± 73'            │ 346     │
-│ 3       │ 'L2 GetOrSet - CacheManager'     │ '3746073 ± 111.65%' │ '707329 ± 20335.00' │ '1378 ± 1.45%'         │ '1414 ± 42'            │ 267     │
-│ 4       │ 'Tiered GetOrSet - BentoCache'   │ '8752.8 ± 98.40%'   │ '1060.0 ± 19.00'    │ '924367 ± 0.04%'       │ '943396 ± 17219'       │ 158461  │
-│ 5       │ 'Tiered GetOrSet - CacheManager' │ '925163 ± 111.45%'  │ '173578 ± 2970.00'  │ '5590 ± 0.55%'         │ '5761 ± 100'           │ 1081    │
-│ 6       │ 'Tiered Get - BentoCache'        │ '556.57 ± 0.52%'    │ '511.00 ± 10.00'    │ '1923598 ± 0.01%'      │ '1956947 ± 37561'      │ 1796720 │
-│ 7       │ 'Tiered Get - CacheManager'      │ '2060.2 ± 2.54%'    │ '1928.0 ± 20.00'    │ '513068 ± 0.02%'       │ '518672 ± 5325'        │ 485387  │
-│ 8       │ 'Tiered Set - BentoCache'        │ '479721 ± 0.38%'    │ '472997 ± 11113.00' │ '2095 ± 0.26%'         │ '2114 ± 50'            │ 2085    │
-│ 9       │ 'Tiered Set - CacheManager'      │ '459758 ± 0.30%'    │ '452934 ± 11205.00' │ '2183 ± 0.23%'         │ '2208 ± 55'            │ 2176    │
+│ 0       │ 'L1 GetOrSet - BentoCache'       │ '8210.2 ± 98.50%'   │ '941.00 ± 18.00'    │ '1029671 ± 0.06%'      │ '1062699 ± 20724'      │ 168254  │
+│ 1       │ 'L1 GetOrSet - CacheManager'     │ '961548 ± 110.99%'  │ '175378 ± 5264.00'  │ '5428 ± 0.81%'         │ '5702 ± 176'           │ 1040    │
+│ 2       │ 'L2 GetOrSet - BentoCache'       │ '2882820 ± 111.63%' │ '548453 ± 19261.00' │ '1770 ± 1.15%'         │ '1823 ± 64'            │ 347     │
+│ 3       │ 'L2 GetOrSet - CacheManager'     │ '3547632 ± 111.55%' │ '687470 ± 17938.00' │ '1426 ± 1.21%'         │ '1455 ± 38'            │ 282     │
+│ 4       │ 'Tiered GetOrSet - BentoCache'   │ '7922.9 ± 98.71%'   │ '932.00 ± 10.00'    │ '1049936 ± 0.05%'      │ '1072961 ± 11637'      │ 174603  │
+│ 5       │ 'Tiered GetOrSet - CacheManager' │ '918338 ± 111.64%'  │ '170190 ± 2282.00'  │ '5678 ± 0.57%'         │ '5876 ± 80'            │ 1089    │
+│ 6       │ 'Tiered Get - BentoCache'        │ '554.00 ± 0.47%'    │ '513.00 ± 10.00'    │ '1933949 ± 0.01%'      │ '1949318 ± 37272'      │ 1805048 │
+│ 7       │ 'Tiered Get - CacheManager'      │ '2012.9 ± 1.80%'    │ '1882.0 ± 28.00'    │ '522571 ± 0.02%'       │ '531350 ± 7789'        │ 496805  │
+│ 8       │ 'Tiered Set - BentoCache'        │ '466705 ± 0.31%'    │ '460615 ± 9501.00'  │ '2151 ± 0.24%'         │ '2171 ± 45'            │ 2143    │
+│ 9       │ 'Tiered Set - CacheManager'      │ '463182 ± 0.39%'    │ '452347 ± 17086.00' │ '2174 ± 0.32%'         │ '2211 ± 84'            │ 2159    │
 └─────────┴──────────────────────────────────┴─────────────────────┴─────────────────────┴────────────────────────┴────────────────────────┴─────────┘
 ```
 

packages/bentocache/src/cache/cache.ts

@@ -90,7 +90,7 @@ export class Cache implements CacheProvider {
    * Set a value in the cache
    * Returns true if the value was set, false otherwise
    */
-  async set(options: SetOptions) {
+  set(options: SetOptions) {
     const cacheOptions = this.#stack.defaultOptions.cloneWith(options)
     return this.#stack.set(options.key, options.value, cacheOptions)
   }
@@ -99,15 +99,15 @@ export class Cache implements CacheProvider {
    * Set a value in the cache forever
    * Returns true if the value was set, false otherwise
    */
-  async setForever(options: SetOptions) {
+  setForever(options: SetOptions) {
     return this.set({ ttl: null, ...options })
   }
 
   /**
    * Retrieve an item from the cache if it exists, otherwise store the value
    * provided by the factory and return it
    */
-  async getOrSet<T>(options: GetOrSetOptions<T>): Promise<T> {
+  getOrSet<T>(options: GetOrSetOptions<T>): Promise<T> {
     const cacheOptions = this.#stack.defaultOptions.cloneWith(options)
     return this.#getSetHandler.handle(options.key, options.factory, cacheOptions)
   }
@@ -116,7 +116,7 @@ export class Cache implements CacheProvider {
    * Retrieve an item from the cache if it exists, otherwise store the value
    * provided by the factory forever and return it
    */
-  async getOrSetForever<T>(options: GetOrSetForeverOptions<T>): Promise<T> {
+  getOrSetForever<T>(options: GetOrSetForeverOptions<T>): Promise<T> {
     const cacheOptions = this.#stack.defaultOptions.cloneWith({ ttl: null, ...options })
     return this.#getSetHandler.handle(options.key, options.factory, cacheOptions)
   }

packages/bentocache/src/cache/get_set/get_set_handler.ts

@@ -20,11 +20,11 @@ export class GetSetHandler {
    * Therefore we come here to determine which handler to use
    * depending on the configuration of the stack.
    */
-  async handle(key: string, factory: Factory, options: CacheEntryOptions) {
+  handle(key: string, factory: Factory, options: CacheEntryOptions) {
     if (this.stack.l2 && !this.stack.l1) {
-      return await this.#singleTierHandler.handle(key, factory, options)
+      return this.#singleTierHandler.handle(key, factory, options)
     }
 
-    return await this.#twoTierHandler.handle(key, factory, options)
+    return this.#twoTierHandler.handle(key, factory, options)
   }
 }

packages/bentocache/src/cache/get_set/two_tier_handler.ts

@@ -112,18 +112,12 @@ export class TwoTierHandler {
     return !!item && !item.isLogicallyExpired()
   }
 
-  async handle(key: string, factory: Factory, options: CacheEntryOptions) {
-    let localItem: CacheEntry | undefined
-
-    /**
-     * First we check the local cache. If we have a valid item, just
-     * returns it without acquiring a lock.
-     */
-    localItem = this.stack.l1?.get(key, options)
-    if (this.#isItemValid(localItem)) {
-      return this.#returnLocalCacheValue(key, localItem, options)
-    }
-
+  async #lockAndHandle(
+    key: string,
+    factory: Factory,
+    options: CacheEntryOptions,
+    localItem?: CacheEntry,
+  ) {
     /**
      * Since we didn't find a valid item in the local cache, we need to
      * check the remote cache, or invoke the factory.
@@ -192,4 +186,22 @@ export class TwoTierHandler {
       throw err
     }
   }
+
+  handle(key: string, factory: Factory, options: CacheEntryOptions) {
+    /**
+     * First we check the local cache. If we have a valid item, just
+     * returns it without acquiring a lock.
+     */
+    const localItem = this.stack.l1?.get(key, options)
+    if (this.#isItemValid(localItem)) {
+      return this.#returnLocalCacheValue(key, localItem, options)
+    }
+
+    /**
+     * Next, delegate to the lock-and-handle async method so we can keep
+     * this method synchronous and avoid an overhead of async/await
+     * in case we have a valid item in the local cache.
+     */
+    return this.#lockAndHandle(key, factory, options, localItem)
+  }
 }