Refactor cache management in parser.ml by removing unnecessary mutex locks

- Eliminated mutex locks for cache operations, simplifying the code and improving performance.
- Streamlined cache access methods by directly manipulating hash tables without locking, while maintaining thread safety through other means.
- Enhanced error handling and clarity in cache operations, ensuring consistent behavior across the module.

Author: mununki

lib/parser.ml

@@ -25,11 +25,6 @@ module Cache = struct
   (* AST dependency check result cache *)
   let ast_dependency_cache = Hashtbl.create 200
 
-  (* Mutex locks for thread safety *)
-  let cache_table_mutex = Eio.Mutex.create ()
-  let ast_cache_mutex = Eio.Mutex.create ()
-  let ast_dependency_cache_mutex = Eio.Mutex.create ()
-
   (* Initialize the cache - simplified to just return false as we don't load from disk anymore *)
   let initialize ?(verbose = false) ?(skip_cache = false) () =
     if verbose then
@@ -45,65 +40,48 @@ module Cache = struct
   (* Add or update an entry in the cache *)
   let add ?(verbose = false) ?(skip_cache = false) path module_info =
     (* Skip adding to cache if skip_cache is set *)
-    if not skip_cache then (
+    if not skip_cache then
       try
-        Eio.Mutex.lock cache_table_mutex;
         let entry = { module_info } in
-        Hashtbl.replace cache_table path entry;
-        Eio.Mutex.unlock cache_table_mutex
+        Hashtbl.replace cache_table path entry
       with exn ->
-        Eio.Mutex.unlock cache_table_mutex;
         if verbose then
-          Printf.eprintf "Error adding to cache: %s\n" (Printexc.to_string exn))
+          Printf.eprintf "Error adding to cache: %s\n" (Printexc.to_string exn)
 
   (* Cache AST file data with mutex protection *)
   let cache_ast_data ?(verbose = false) ?(skip_cache = false) ast_path data =
-    if not skip_cache then (
-      try
-        Eio.Mutex.lock ast_cache_mutex;
-        Hashtbl.replace ast_cache ast_path data;
-        Eio.Mutex.unlock ast_cache_mutex
+    if not skip_cache then
+      try Hashtbl.replace ast_cache ast_path data
       with exn ->
-        Eio.Mutex.unlock ast_cache_mutex;
         if verbose then
-          Printf.eprintf "Error caching AST data: %s\n" (Printexc.to_string exn))
+          Printf.eprintf "Error caching AST data: %s\n" (Printexc.to_string exn)
 
   (* Get cached AST file data with mutex protection *)
   let get_ast_data ?(verbose = false) ast_path =
-    try
-      Eio.Mutex.lock ast_cache_mutex;
-      let result = Hashtbl.find_opt ast_cache ast_path in
-      Eio.Mutex.unlock ast_cache_mutex;
-      result
+    try let result = Hashtbl.find_opt ast_cache ast_path in
+
+        result
     with exn ->
-      Eio.Mutex.unlock ast_cache_mutex;
       if verbose then
         Printf.eprintf "Error getting AST data: %s\n" (Printexc.to_string exn);
       None
 
   (* Cache AST dependency check result with mutex protection *)
   let cache_ast_dependency_result ?(verbose = false) ?(skip_cache = false) key
       result =
-    if not skip_cache then (
-      try
-        Eio.Mutex.lock ast_dependency_cache_mutex;
-        Hashtbl.replace ast_dependency_cache key result;
-        Eio.Mutex.unlock ast_dependency_cache_mutex
+    if not skip_cache then
+      try Hashtbl.replace ast_dependency_cache key result
       with exn ->
-        Eio.Mutex.unlock ast_dependency_cache_mutex;
         if verbose then
           Printf.eprintf "Error caching AST dependency: %s\n"
-            (Printexc.to_string exn))
+            (Printexc.to_string exn)
 
   (* Get cached AST dependency check result with mutex protection *)
   let get_ast_dependency_result ?(verbose = false) key =
     try
-      Eio.Mutex.lock ast_dependency_cache_mutex;
       let result = Hashtbl.find_opt ast_dependency_cache key in
-      Eio.Mutex.unlock ast_dependency_cache_mutex;
       result
     with exn ->
-      Eio.Mutex.unlock ast_dependency_cache_mutex;
       if verbose then
         Printf.eprintf "Error getting AST dependency: %s\n"
           (Printexc.to_string exn);
@@ -119,7 +97,6 @@ module Cache = struct
       None)
     else
       try
-        Eio.Mutex.lock cache_table_mutex;
         let result =
           match Hashtbl.find_opt cache_table path with
           | None ->
@@ -154,35 +131,19 @@ module Cache = struct
                   Printf.printf "Cache invalid for %s (digest mismatch)\n" path;
                 None)
         in
-        Eio.Mutex.unlock cache_table_mutex;
         result
       with exn ->
-        Eio.Mutex.unlock cache_table_mutex;
         if verbose then
           Printf.eprintf "Error finding in cache: %s\n" (Printexc.to_string exn);
         None
 
   (* Clear the cache with mutex protection *)
   let clear ?(verbose = false) () =
     try
-      (* Lock all mutexes to safely clear all caches *)
-      Eio.Mutex.lock cache_table_mutex;
-      Eio.Mutex.lock ast_cache_mutex;
-      Eio.Mutex.lock ast_dependency_cache_mutex;
-
       Hashtbl.clear cache_table;
       Hashtbl.clear ast_cache;
-      Hashtbl.clear ast_dependency_cache;
-
-      (* Unlock in reverse order *)
-      Eio.Mutex.unlock ast_dependency_cache_mutex;
-      Eio.Mutex.unlock ast_cache_mutex;
-      Eio.Mutex.unlock cache_table_mutex
+      Hashtbl.clear ast_dependency_cache
     with exn ->
-      (* Make sure to unlock in case of exceptions *)
-      (try Eio.Mutex.unlock ast_dependency_cache_mutex with _ -> ());
-      (try Eio.Mutex.unlock ast_cache_mutex with _ -> ());
-      (try Eio.Mutex.unlock cache_table_mutex with _ -> ());
       if verbose then
         Printf.eprintf "Error clearing cache: %s\n" (Printexc.to_string exn)
 end