perf: remove getters and use standard functions

Author: Julien-R44

.changeset/thick-tomatoes-watch.md

@@ -0,0 +1,37 @@
+---
+'bentocache': patch
+---
+
+Deleted the getters usage in the CacheEntryOptions file. Looks like getters are super slow. Just removing them doubled the performance in some cases. 
+
+Before : 
+
+```sh
+┌─────────┬──────────────────────────────────┬─────────────────────┬─────────────────────┬────────────────────────┬────────────────────────┬─────────┐
+│ (index) │ Task name                        │ Latency avg (ns)    │ Latency med (ns)    │ Throughput avg (ops/s) │ Throughput med (ops/s) │ Samples │
+├─────────┼──────────────────────────────────┼─────────────────────┼─────────────────────┼────────────────────────┼────────────────────────┼─────────┤
+│ 0       │ 'L1 GetOrSet - BentoCache'       │ '16613 ± 97.87%'    │ '1560.0 ± 45.00'    │ '613098 ± 0.10%'       │ '641026 ± 19040'       │ 83796   │
+│ 1       │ 'L1 GetOrSet - CacheManager'     │ '953451 ± 111.03%'  │ '160022 ± 3815.00'  │ '5700 ± 1.23%'         │ '6249 ± 151'           │ 1049    │
+│ 4       │ 'Tiered GetOrSet - BentoCache'   │ '16105 ± 98.11%'    │ '1515.0 ± 45.00'    │ '636621 ± 0.08%'       │ '660066 ± 20206'       │ 86675   │
+│ 5       │ 'Tiered GetOrSet - CacheManager' │ '877297 ± 111.36%'  │ '161617 ± 2876.00'  │ '5948 ± 0.67%'         │ '6187 ± 112'           │ 1140    │
+│ 6       │ 'Tiered Get - BentoCache'        │ '1542.4 ± 4.43%'    │ '992.00 ± 18.00'    │ '973931 ± 0.03%'       │ '1008065 ± 17966'      │ 648343  │
+│ 7       │ 'Tiered Get - CacheManager'      │ '1957.6 ± 0.51%'    │ '1848.0 ± 26.00'    │ '534458 ± 0.02%'       │ '541126 ± 7722'        │ 510827  │
+└─────────┴──────────────────────────────────┴─────────────────────┴─────────────────────┴────────────────────────┴────────────────────────┴─────────┘
+```
+
+After: 
+
+```sh
+┌─────────┬──────────────────────────────────┬─────────────────────┬─────────────────────┬────────────────────────┬────────────────────────┬─────────┐
+│ (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    │
+│ 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  │
+└─────────┴──────────────────────────────────┴─────────────────────┴─────────────────────┴────────────────────────┴────────────────────────┴─────────┘
+```
+
+Pretty good improvement 😁

packages/bentocache/src/cache/cache.ts

@@ -66,7 +66,7 @@ export class Cache implements CacheProvider {
       return remoteItem.getValue()
     }
 
-    if (!options.isGraceEnabled) {
+    if (!options.isGraceEnabled()) {
       this.#stack.emit(cacheEvents.miss(key, this.name))
       return this.#resolveDefaultValue(defaultValueFn)
     }

packages/bentocache/src/cache/cache_entry/cache_entry_options.ts

@@ -59,7 +59,7 @@ export function createCacheEntryOptions(
      * Logical TTL is when the value is considered expired
      * but still can be in the cache ( Grace period )
      */
-    get logicalTtl() {
+    getLogicalTtl() {
       return logicalTtl
     },
 
@@ -68,14 +68,14 @@ export function createCacheEntryOptions(
      * removed from the cache. This is the Grace period
      * duration
      */
-    get physicalTtl() {
+    getPhysicalTtl() {
       return physicalTtl
     },
 
     /**
      * Determine if the gracing system is enabled
      */
-    get isGraceEnabled() {
+    isGraceEnabled() {
       return grace > 0
     },
 
@@ -111,7 +111,7 @@ export function createCacheEntryOptions(
       options.ttl = newTtl
 
       logicalTtl = resolveTtl(options.ttl)
-      physicalTtl = self.isGraceEnabled ? grace : logicalTtl
+      physicalTtl = self.isGraceEnabled() ? grace : logicalTtl
 
       return self
     },
@@ -139,7 +139,7 @@ export function createCacheEntryOptions(
      * factory
      */
     factoryTimeout(hasFallbackValue: boolean) {
-      if (hasFallbackValue && self.isGraceEnabled && is.number(timeout)) {
+      if (hasFallbackValue && self.isGraceEnabled() && is.number(timeout)) {
         return { type: 'soft', duration: timeout, exception: errors.E_FACTORY_SOFT_TIMEOUT }
       }
 
@@ -152,7 +152,7 @@ export function createCacheEntryOptions(
      * Determine if we should use the SWR strategy
      */
     shouldSwr(hasFallback: boolean) {
-      return self.isGraceEnabled && timeout === 0 && hasFallback
+      return self.isGraceEnabled() && timeout === 0 && hasFallback
     },
 
     /**
@@ -167,7 +167,7 @@ export function createCacheEntryOptions(
        * that means we should wait at most for the soft timeout
        * duration.
        */
-      if (hasFallbackValue && self.isGraceEnabled && typeof timeout === 'number') {
+      if (hasFallbackValue && self.isGraceEnabled() && typeof timeout === 'number') {
         return timeout
       }
     },

packages/bentocache/src/cache/facades/local_cache.ts

@@ -45,15 +45,16 @@ export class LocalCache {
     /**
      * If grace period is disabled and Physical TTL is 0 or less, we can just delete the item.
      */
-    if (!options.isGraceEnabled && options.physicalTtl && options.physicalTtl <= 0) {
+    const physicalTtl = options.getPhysicalTtl()
+    if (!options.isGraceEnabled() && physicalTtl && physicalTtl <= 0) {
       return this.delete(key, options)
     }
 
     /**
      * Save the item to the local cache
      */
     this.#logger.trace({ key, value, opId: options.id }, 'saving local cache item')
-    this.#driver.set(key, value, options.physicalTtl)
+    this.#driver.set(key, value, physicalTtl)
   }
 
   /**

packages/bentocache/src/cache/facades/remote_cache.ts

@@ -73,7 +73,7 @@ export class RemoteCache {
    */
   async set(key: string, value: string, options: CacheEntryOptions) {
     return await this.#tryCacheOperation('set', options, false, async () => {
-      await this.#driver.set(key, value, options.physicalTtl)
+      await this.#driver.set(key, value, options.getPhysicalTtl())
       return true
     })
   }

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

@@ -25,10 +25,6 @@ export class SingleTierHandler {
     return this.stack.logger
   }
 
-  get emitter() {
-    return this.stack.emitter
-  }
-
   /**
    * Emit a CacheEvent using the emitter
    */
@@ -63,7 +59,7 @@ export class SingleTierHandler {
     options: CacheEntryOptions,
     err: Error,
   ) {
-    if (options.isGraceEnabled && item) {
+    if (options.isGraceEnabled() && item) {
       const isLogicallyExpired = item.isLogicallyExpired()
       this.#emit(cacheEvents.hit(key, item.getValue(), this.stack.name, isLogicallyExpired))
       this.logger.trace(
@@ -158,7 +154,7 @@ export class SingleTierHandler {
         'factory error',
       )
 
-      if (staleItem && options.isGraceEnabled) {
+      if (staleItem && options.isGraceEnabled()) {
         this.#locks.release(key, releaser)
         return this.#applyFallbackAndReturnGracedValue(key, staleItem, options)
       }

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

@@ -25,10 +25,6 @@ export class TwoTierHandler {
     return this.stack.logger
   }
 
-  get emitter() {
-    return this.stack.emitter
-  }
-
   /**
    * Emit a CacheEvent using the emitter
    */
@@ -83,7 +79,7 @@ export class TwoTierHandler {
     options: CacheEntryOptions,
     err: Error,
   ) {
-    if (options.isGraceEnabled && item) {
+    if (options.isGraceEnabled() && item) {
       return this.#returnLocalCacheValue(key, item, options, 'local cache hit (graced)')
     }
 
@@ -187,7 +183,7 @@ export class TwoTierHandler {
         'factory error',
       )
 
-      if (staleItem && options.isGraceEnabled) {
+      if (staleItem && options.isGraceEnabled()) {
         this.#locks.release(key, releaser)
         return this.#applyFallbackAndReturnGracedValue(key, staleItem, options)
       }

packages/bentocache/tests/cache/cache_entry_options.spec.ts

@@ -10,31 +10,31 @@ test.group('Cache Entry Options', () => {
 
     const options = createCacheEntryOptions(override, defaults)
 
-    assert.equal(options.logicalTtl, string.milliseconds.parse('10m'))
-    assert.equal(options.physicalTtl, string.milliseconds.parse('30m'))
+    assert.equal(options.getLogicalTtl(), string.milliseconds.parse('10m'))
+    assert.equal(options.getPhysicalTtl(), string.milliseconds.parse('30m'))
   })
 
   test('physical ttl should be logical ttl when grace period is disabled', ({ assert }) => {
     const options = createCacheEntryOptions({ ttl: '10m' })
 
-    assert.equal(options.physicalTtl, string.milliseconds.parse('10m'))
+    assert.equal(options.getPhysicalTtl(), string.milliseconds.parse('10m'))
   })
 
   test('physical ttl should be grace period ttl when enabled', ({ assert }) => {
     const options = createCacheEntryOptions({ ttl: '10m', grace: '30m' })
-    assert.equal(options.physicalTtl, string.milliseconds.parse('30m'))
+    assert.equal(options.getPhysicalTtl(), string.milliseconds.parse('30m'))
   })
 
   test('null ttl should be kept and resolved to undefined', ({ assert }) => {
     const options = createCacheEntryOptions({ ttl: null, grace: '30m' })
-    assert.deepEqual(options.logicalTtl, undefined)
+    assert.deepEqual(options.getLogicalTtl(), undefined)
   })
 
   test('clone with null ttl should be kept and resolved as undefined', ({ assert }) => {
     const options = createCacheEntryOptions({ ttl: '10m', grace: '30m' })
     const clone = options.cloneWith({ ttl: null })
 
-    assert.deepEqual(clone.logicalTtl, undefined)
+    assert.deepEqual(clone.getLogicalTtl(), undefined)
   })
 
   test('should assign timeouts', ({ assert }) => {
@@ -65,8 +65,8 @@ test.group('Cache Entry Options', () => {
     const r1 = createCacheEntryOptions({ grace: false })
     const r2 = r1.cloneWith({ grace: '60m' })
 
-    assert.isFalse(r1.isGraceEnabled)
-    assert.isTrue(r2.isGraceEnabled)
+    assert.isFalse(r1.getIsGraceEnabled())
+    assert.isTrue(r2.getIsGraceEnabled())
   })
 
   test('timeout should be soft one if fallback value and grace period enabled', ({ assert }) => {
@@ -112,7 +112,7 @@ test.group('Cache Entry Options', () => {
 
     options.setLogicalTtl(string.milliseconds.parse('5m'))
 
-    assert.equal(options.logicalTtl, string.milliseconds.parse('5m'))
-    assert.equal(options.physicalTtl, string.milliseconds.parse('5m'))
+    assert.equal(options.getLogicalTtl(), string.milliseconds.parse('5m'))
+    assert.equal(options.getPhysicalTtl(), string.milliseconds.parse('5m'))
   })
 })