+=======
+int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*start_routine)(void*), void* arg)
+{
+ if (not raw_pthread_create)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_pthread_create(thread, attr, start_routine, arg);
+
+ sthread_disable();
+ int res = sthread_create(reinterpret_cast<sthread_t*>(thread), attr, start_routine, arg);
+ sthread_enable();
+ return res;
+}
+int pthread_join(pthread_t thread, void** retval)
+{
+ if (not raw_pthread_join)
+ intercepter_init();
+ if (sthread_inside_simgrid)
+ return raw_pthread_join(thread, retval);
+
+ sthread_disable();
+ int res = sthread_join(reinterpret_cast<sthread_t>(thread), retval);
+ sthread_enable();
+ return res;
+}
+
+int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr)
+{
+ if (not raw_mutex_init)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_mutex_init(mutex, attr);
+
+ sthread_disable();
+ int res = sthread_mutex_init(reinterpret_cast<sthread_mutex_t*>(mutex), attr);
+ sthread_enable();
+ return res;
+}
+
+int pthread_mutex_lock(pthread_mutex_t* mutex)
+{
+ if (not raw_mutex_lock)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_mutex_lock(mutex);
+
+ sthread_disable();
+ int res = sthread_mutex_lock(reinterpret_cast<sthread_mutex_t*>(mutex));
+ sthread_enable();
+ return res;
+}
+
+int pthread_mutex_trylock(pthread_mutex_t* mutex)
+{
+ if (not raw_mutex_trylock)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_mutex_trylock(mutex);
+
+ sthread_disable();
+ int res = sthread_mutex_trylock(reinterpret_cast<sthread_mutex_t*>(mutex));
+ sthread_enable();
+ return res;
+}
+
+int pthread_mutex_unlock(pthread_mutex_t* mutex)
+{
+ if (not raw_mutex_unlock)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_mutex_unlock(mutex);
+
+ sthread_disable();
+ int res = sthread_mutex_unlock(reinterpret_cast<sthread_mutex_t*>(mutex));
+ sthread_enable();
+ return res;
+}
+int pthread_mutex_destroy(pthread_mutex_t* mutex)
+{
+ if (not raw_mutex_destroy)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_mutex_destroy(mutex);
+
+ sthread_disable();
+ int res = sthread_mutex_destroy(reinterpret_cast<sthread_mutex_t*>(mutex));
+ sthread_enable();
+ return res;
+}
+int sem_init(sem_t* sem, int pshared, unsigned int value)
+{
+ if (not raw_sem_init)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_init(sem, pshared, value);
+
+ sthread_disable();
+ int res = sthread_sem_init(reinterpret_cast<sthread_sem_t*>(sem), pshared, value);
+ sthread_enable();
+ return res;
+}
+int sem_destroy(sem_t* sem)
+{
+ if (not raw_sem_destroy)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_destroy(sem);
+
+ sthread_disable();
+ int res = sthread_sem_destroy(reinterpret_cast<sthread_sem_t*>(sem));
+ sthread_enable();
+ return res;
+}
+int sem_post(sem_t* sem)
+{
+ if (not raw_sem_post)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_post(sem);
+
+ sthread_disable();
+ int res = sthread_sem_post(reinterpret_cast<sthread_sem_t*>sem);
+ sthread_enable();
+ return res;
+}
+int sem_wait(sem_t* sem)
+{
+ if (not raw_sem_wait)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_wait(sem);
+
+ sthread_disable();
+ int res = sthread_sem_wait(reinterpret_cast<sthread_sem_t*>(sem));
+ sthread_enable();
+ return res;
+}
+int sem_trywait(sem_t* sem)
+{
+ if (not raw_sem_trywait)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_trywait(sem);
+
+ sthread_disable();
+ int res = sthread_sem_trywait(reinterpret_cast<sthread_sem_t*>(sem));
+ sthread_enable();
+ return res;
+}
+int sem_timedwait(sem_t* sem, const struct timespec* abs_timeout)
+{
+ if (not raw_sem_timedwait)
+ intercepter_init();
+
+ if (sthread_inside_simgrid)
+ return raw_sem_timedwait(sem, abs_timeout);
+
+ sthread_disable();
+ int res = sthread_sem_timedwait(reinterpret_cast<sthread_sem_t*>(sem), abs_timeout);
+ sthread_enable();
+ return res;
+}
+>>>>>>> Convert sthread.c to C++.:src/sthread/sthread.cpp