1. How is safely defined?
Semantically. In this case, this is not a hard-defined term. It just mean "You can do that, without risk".
2. If a program can be safely executed concurrently, does it always mean that it is reentrant?
No.
For example, let's have a C++ function that takes both a lock, and a callback as a parameter:
typedef void (*MyCallback)() ;
void myFunction(MyCallback f)
{
lock(mutex) ;
f() ;
unlock(mutex) ;
}
At first sight, this function seems Ok... But wait:
int main(int argc, char * argv[])
{
myFunction(myFunction) ;
return 0 ;
}
If the lock/mutex is not recursive, then here's what will happen:
main will call myFunctionmyFunction will acquire the lockmyFunction will call myFunction- the 2nd
myFunction will try acquire the lock and wait for it to be released
- Deadlock.
- Oops...
Ok, I cheated, using the Callback thing. But it's easy to imagine more complex pieces of code having a similar effect.
3. What exactly is the common thread between the six points mentioned that I should keep in mind while checking my code for reentrant capabilities?
You can smell a problem if your function has/gives access to a modifiable persistent resource, or has/gives access to a function that smells.
(Ok, 99% of our code should smell, then... See last section to handle that...)
So, studying your code, one of those points should alert you:
- The function has a state (i.e. access a global variable, or even a class member variable)
- This function can be called my multiple threads, or could appear twice in the stack while the process is executing (i.e. the function could call itself, directly or indirectly). Function taking callbacks as parameters smell a lot.
Note that non-reentrancy is viral : A function that could call a possible non-reentrant function cannot be considered reentrant.
Note, too, that C++ methods smell because they have access to this, so you should study the code to be sure they have no funny interaction.
4.1. Are all recursive functions reentrant?
No.
In multithreaded cases, a recursive function accessing a shared resources could be called by multiple threads at the same moment, resulting in bad/corrupted data.
In singlethreaded cases, a recursive function could use a non-reentrant function (like infamous strtok), or use global data without handling the fact the data is already in use. So you function is recursive because it calls itself directly or indirectly, but it can still be recursive-unsafe.
4.2. Are all thread-safe functions reentrant?
In the example above, I showed how an apparently threadsafe function was not reentrant. Ok I cheated because of the Callback parameter. But then, there are multiple ways to deadlock a thread by having it acquire twice a non-reccursive lock.
4.3. Are all recursive and thread-safe functions reentrant?
I would say "yes" if by "recursive" you mean "recursive-safe".
If you can guarantee that a function can be called simultaneously by multiple threads, and can call itself, directly or indirectly, without problems, then it is reentrant.
The problem is evaluating this guarantee... ^_^
5. Are the terms like reentrance and thread safety absolute at all i.e. do they have fixed concrete definations?
I believe they have, but then, evaluating a function is thread-safe or reentrant can be difficult. This is why I used the term smell above: You can find a function is not reentrant, but it could be difficult to be sure a complex piece of code is reentrant
6. An example
Let's say you have an object, with one method that need to use a resources:
struct MyStruct
{
P * p ;
void foo()
{
if(this->p == NULL)
{
this->p = new P() ;
}
// Lots of code, some using this->p
if(this->p != NULL)
{
delete this->p ;
this->p = NULL ;
}
}
} ;
The first problem is that if somehow this function is called recursively (i.e. this function calls itself, directly or indirectly), the code will probably crash, because this->p will be deleted at the end of the last call, and still probably be used before the end of the first call.
Thus, this code is not recursive-safe.
We could use a reference counter to correct this:
struct MyStruct
{
size_t c ;
P * p ;
void foo()
{
if(c == 0)
{
this->p = new P() ;
}
++c ;
// Lots of code, some using this->p
--c ;
if(c == 0)
{
delete this->p ;
this->p = NULL ;
}
}
} ;
This way, the code becomes recursive-safe... But it is still not reentrant because of multithreading issues: We must be sure the modifications of c and of p will be done atomically, using a recursive mutex (not all mutexes are recursive):
struct MyStruct
{
mutex m ; // recursive mutex
size_t c ;
P * p ;
void foo()
{
lock(m) ;
if(c == 0)
{
this->p = new P() ;
}
++c ;
unlock(m) ;
// Lots of code, some using this->p
lock(m) ;
--c ;
if(c == 0)
{
delete this->p ;
this->p = NULL ;
}
unlock(m) ;
}
} ;
And of course, this all assumes the lots of code is itself reentrant, including the use of p.
And the code above is not even remotely exception-safe, but this is another story... ^_^
7. Hey 99% of our code is not reentrant!!
It is quite true for spaghetti code. But if you partition correctly your code, you will avoid reentrancy problems.
7.1. Make sure all functions have NO state.
They must only use the parameters, their own local variables, other functions without state, and return copies of the data if they return at all.
7.2. Make sure your object is "recursive-safe".
An object method has access to this, so it shares a state with all the methods of the same instance of the object.
So, make sure the object can be used at one point in the stack (i.e. calling method A), and then, at another point (i.e. calling method B), without corrupting the whole object. Design your object to make sure that upon exiting a method, the object is stable and correct (no dangling pointers, no contradicting member variables, etc.).
7.3. Make sure all your objects are correctly encapsulated.
No one else should have access to their internal data:
// bad
int & MyObject::getCounter()
{
return this->counter ;
}
// good
int MyObject::getCounter()
{
return this->counter ;
}
// good, too
void MyObject::getCounter(int & p_counter)
{
p_counter = this->counter ;
}
Even returning a const reference could be dangerous if the use retrieves the address of the data, as some other portion of the code could modify it without the code holding the const reference being told.
7.4. Make sure the user knows you object is not thread-safe
Thus, the user is responsible to use mutexes to use an object shared between threads.
The objects from the STL are designed to be not thread-safe (because of performance issues), and thus, if a user want to share a std::string between two threads, the user must protect its access with concurrency primitives;
7.5. Make sure you thread-safe code is recursive-safe
This means using recursive mutexes if you believe the same resource can be used twice by the same thread.