Updating Caching Performance

Author: sarthakbabbar3

modules/writing_observer/writing_observer/awe_nlp.py

@@ -22,6 +22,7 @@
 import awe_components.components.viewpointFeatures
 import awe_components.components.lexicalClusters
 import awe_components.components.contentSegmentation
+from writing_observer.caching_performance import CachePerformance
 import json
 import warnings
 
@@ -30,6 +31,7 @@
 import learning_observer.util
 
 RUN_MODES = enum.Enum('RUN_MODES', 'MULTIPROCESSING SERIAL')
+cache_stats = CachePerformance()
 
 
 def init_nlp():
@@ -316,6 +318,15 @@ async def process_and_cache_missing_features(unfound_features, found_features, r
     await cache.set(text_hash, text_cache_data)
     return writing
 
+async def update_cache_stats(hits=0, misses=0):
+    """
+    Updates cache statistics like Hits and Misses.
+    """
+    if hits!= 0:
+        await cache_stats.increment_hit_count(hits)
+    if misses!=0:
+        await cache_stats.increment_miss_count(misses)
+
 
 async def process_writings_with_caching(writing_data, options=None, mode=RUN_MODES.MULTIPROCESSING, sleep_interval=1, wait_time_for_running_features=60):
     '''
@@ -360,18 +371,23 @@ async def process_writings_with_caching(writing_data, options=None, mode=RUN_MOD
         # If all options were found
         if found_features == requested_features:
             results.append(writing)
+            await update_cache_stats(hits=len(found_features))
             continue
 
         # Check if some options are a subset of running_features: features that are needed but are already running
         unfound_features, found_features, writing = await check_and_wait_for_running_features(writing, requested_features, found_features, cache, sleep_interval, wait_time_for_running_features, text_hash)
         # If all options are found
         if found_features == requested_features:
             results.append(writing)
+            await update_cache_stats(hits=len(found_features))
             continue
 
         # Add not found options to running_features and update cache
         results.append(await process_and_cache_missing_features(unfound_features, found_features, requested_features, cache, text_hash, writing))
 
+        # Update Cache Performance
+        await update_cache_stats(hits=len(found_features), misses=len(unfound_features))
+
     return results
 
 

modules/writing_observer/writing_observer/caching_performance.py

@@ -1,26 +1,31 @@
 import asyncio
 
-# In-Memory Counters
-HIT_COUNT = 0
-MISS_COUNT = 0
-
 # Asyncio Locks for the in-memory counters. https://docs.python.org/3/library/asyncio-sync.html
 hit_lock = asyncio.Lock()
 miss_lock = asyncio.Lock()
 
-async def increment_hit_count():
-    """
-    Increments the hit count by 1
-    """
-    global HIT_COUNT
-    async with hit_lock: #Acquires and releases the locks after finished.
-        HIT_COUNT += 1
-    print(HIT_COUNT)
 
-async def increment_miss_count():
+class CachePerformance():
     """
-    Increments the miss count by 1
+    A class to track caching performance through cache hits and misses.
     """
-    global MISS_COUNT
-    async with miss_lock: #Acquires and releases the locks after finished.
-        MISS_COUNT += 1
+    def __init__(self):
+        # In-Memory Counters
+        self.HIT_COUNT = 0
+        self.MISS_COUNT = 0
+        
+    async def increment_hit_count(self, hits=1):
+        """
+        Increments the hit count by number of hits
+        """
+        async with hit_lock: #Acquires and releases the locks after finished.
+            self.HIT_COUNT += hits
+            print(f"Hit Count: {self.HIT_COUNT}")
+
+    async def increment_miss_count(self, misses=1):
+        """
+        Increments the miss count by number of misses.
+        """
+        async with miss_lock: #Acquires and releases the locks after finished.
+            self.MISS_COUNT += misses
+            print(f"Miss Count: {self.MISS_COUNT}")

testcode/TestCachingPerformance.py

@@ -1,14 +1,13 @@
 import asyncio 
-from writing_observer.caching_performance import increment_hit_count, increment_miss_count, HIT_COUNT, MISS_COUNT
+from writing_observer.caching_performance import CachePerformance
 
 # entry point
 async def main():
-    print(f"Initial Hit Count: {HIT_COUNT}")
+    cache_performance = CachePerformance()
     number_of_coroutines = 10
     # create many concurrent coroutines
-    coros = [increment_hit_count() for i in range(number_of_coroutines)]
+    coros = [cache_performance.increment_hit_count(2) for i in range(number_of_coroutines)]
     # execute and wait for tasks to complete
     await asyncio.gather(*coros)
-    print(HIT_COUNT)
 
 asyncio.run(main())