Changeset 1197

Timestamp:

02/05/23 22:48:52 (21 months ago)

Author:

Maciej Komosinski

Message:

Added the "-t" option in init() to make concurrent calls from different threads sequential, thus making them safe

File:

• framspy/frams.py (modified) (4 diffs)

framspy/frams.py

@@ -17 +17 @@
 If you want to run many independent instances of this class in parallel, use the "multiprocessing" module and then each process
 that uses this module will initialize it and get access to a separate instance of the Framsticks library.
+
+If you want to use this module from multiple threads concurrently, use the "-t" option for init().
+This will make concurrent calls from different threads sequential, thus making them safe.
+However, this will likely degrade the performance (due to required locking) compared to the single-threaded use.
 
 For interfaces in other languages (e.g. using the Framsticks library in your C++ code), see ../cpp/frams/frams-objects.h
@@ -308 +312 @@
         '-LNAME' is the optional library name (full name including the file name extension), default is 'frams-objects.dll/.so' depending on the platform.
         All other arguments are passed to Framsticks and not interpreted by this function.
-
         """
-        # goals:
+
         frams_d = None
         frams_D = None
@@ -323 +326 @@
                 elif a[:2] == '-L':
                         lib_name = a[2:]
+                elif a[:2] == '-t':
+                        print("frams.py: thread synchronization enabled.")  # Due to performance penalty, only use if you are really calling methods from different threads.
+                        from functools import wraps
+                        from threading import RLock
+                        
+                        def threads_synchronized(lock):
+                                def wrapper(f):
+                                        @wraps(f)
+                                        def inner_wrapper(*args, **kwargs):
+                                                with lock:
+                                                        return f(*args, **kwargs)
+                                        return inner_wrapper
+                                return wrapper
+
+                        thread_synchronizer = threads_synchronized(RLock())
+                        for name in ExtValue.__dict__:
+                                attr = getattr(ExtValue, name)
+                                if callable(attr) and attr:  # decorate all methods of ExtValue with a reentrant lock so that different threads do not use them concurrently
+                                        setattr(ExtValue, name, thread_synchronizer(attr))
                 elif lib_path is None:
                         lib_path = a
@@ -340 +362 @@
         abs_data = os.path.join(os.path.abspath(lib_path), "data")  # use absolute path for -d and -D so python is free to cd anywhere without confusing Framsticks
 
-        # for the hypothetical case without lib_path the abs_data must be obtained from somewhere else
+        # for the hypothetical case without lib_path, the abs_data must be obtained from somewhere else
         if frams_d is None:
                 frams_d = '-d' + abs_data