some optimizations for async locks and events

Author: d-biehl

robotcode/jsonrpc2/protocol.py

@@ -5,6 +5,7 @@
 import json
 import re
 import threading
+import time
 import weakref
 from abc import ABC, abstractmethod
 from collections import OrderedDict
@@ -608,8 +609,13 @@ def set_result(f: asyncio.Future[Any], r: Any, ev: threading.Event) -> None:
 
                         entry.future.get_loop().call_soon_threadsafe(set_result, entry.future, res, done)
 
-                        if not done.wait(120):
-                            raise TimeoutError("Can't set response result")
+                        start = time.monotonic()
+                        while not done.is_set():
+
+                            if time.monotonic() - start > 120:
+                                raise TimeoutError("Can't set future result.")
+
+                            await asyncio.sleep(0.001)
 
                     else:
                         self._logger.warning("Response loop is not running.")

robotcode/language_server/robotframework/parts/references.py

@@ -116,9 +116,13 @@ async def _find_references_in_workspace(
 
         result: List[Location] = []
 
+        # tasks = []
         for doc in self.parent.documents.documents:
             if doc.language_id == "robotframework":
                 result.extend(await func(doc, *args, **kwargs))
+                # tasks.append(run_coroutine_in_thread(func, doc, *args, **kwargs))
+
+        # result = await asyncio.gather(*tasks)
 
         return result
 

robotcode/utils/async_tools.py

@@ -7,6 +7,7 @@
 import functools
 import inspect
 import threading
+import time
 import weakref
 from collections import deque
 from concurrent.futures.thread import ThreadPoolExecutor
@@ -443,7 +444,7 @@ def set(self) -> None:
                                 fut.set_result(True)
                         else:
 
-                            def s(w: asyncio.Future[Any], ev: threading.Event) -> None:
+                            def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
                                 try:
                                     if not w.done():
                                         w.set_result(True)
@@ -453,7 +454,7 @@ def s(w: asyncio.Future[Any], ev: threading.Event) -> None:
                             if not fut.done():
                                 done = threading.Event()
 
-                                fut.get_loop().call_soon_threadsafe(s, fut, done)
+                                fut.get_loop().call_soon_threadsafe(set_result, fut, done)
 
                                 if not done.wait(120):
                                     raise TimeoutError("Callback timeout.")
@@ -519,8 +520,13 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
 
                                 waiter.get_loop().call_soon_threadsafe(set_result, waiter, done)
 
-                                if not done.wait(120):
-                                    raise TimeoutError("Callback timeout.")
+                                start = time.monotonic()
+                                while not done.is_set():
+
+                                    if time.monotonic() - start > 120:
+                                        raise TimeoutError("Can't set future result.")
+
+                                    await asyncio.sleep(0.001)
 
     def locked(self) -> bool:
         with self._lock:
@@ -708,8 +714,16 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
 
                     fut.get_loop().call_soon_threadsafe(set_result, fut, done)
 
-                    if not done.wait(120):
-                        raise TimeoutError("Callback timeout.")
+                    start = time.monotonic()
+                    while not done.is_set():
+
+                        if time.monotonic() - start > 120:
+                            raise TimeoutError("Can't set future result.")
+
+                        await asyncio.sleep(0.001)
+
+                    # if not done.wait(120):
+                    #     raise TimeoutError("Callback timeout.")
 
 
 class FutureInfo: