There's a large shared object (kind of OpenGL context) in my project.
It is accessed from multiple threads.
To ensure only one thread at the moments is using SHARED_OBJECT, mutex (kind of NSRecursiveLock) is used.
The problem is that sometimes MAIN_THREAD is waiting a lot while some BG_THREAD is doing something with SHARED_OBJECT.
I am not supposed to change architecture (to rewrite this mutex scheme).
The current problem lies in following:
There is my_backround_func (takes a lot of time), which is called before main_thread_func1(takes few milliseconds) and main_thread_func2.
These functions are spread all over the project.
To fix the problem, I created singleton class Dispatcher, which lets main_thread_func* to be registered, and lets my_backround_func to ask if all main_thread_funcs were already executed.
It uses Objective C mechanisms like NSStringFromSelector and "_cmd".
At the start of the program I register functions:
[[MyBackgroundFunctionDispatcher dispatcher] setCanCallBgFunc:NO forSelector:NSStringFromSelector(@selector(main_thread_func1:))];
[[MyBackgroundFunctionDispatcher dispatcher] setCanCallBgFunc:NO forSelector:NSStringFromSelector(@selector(main_thread_func2:))];
And at the end of main_thread_func1 and main_thread_func2 I call
[[MyBackgroundFunctionDispatcher dispatcher] setCanCallBgFunc:YES forSelector:NSStringFromSelector(_cmd)];
All this time background thread is waiting:
while ( ![[MyBackgroundFunctionDispatcher dispatcher] setCanCallBgFunc] )
sleep_ms(10);
So, I ensured that background function will be caller AFTER registered main thread functions. MyBackgroundFunctionDispatcher can be extended to hold registered functions not only for my_backround_func, but for my_backround_func1, my_backround_func2.
While the solution looks ugly and I suspect I miss some good pattern.
Could you give any advices please?
