incubator-celix-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From abroekh...@apache.org
Subject svn commit: r1600183 - in /incubator/celix/trunk: framework/private/include/ framework/private/src/ framework/public/include/ utils/private/src/ utils/public/include/
Date Wed, 04 Jun 2014 13:11:45 GMT
Author: abroekhuis
Date: Wed Jun  4 13:11:44 2014
New Revision: 1600183

URL: http://svn.apache.org/r1600183
Log:
CELIX-119: Updated framework to use pthreads (via a wrapper).

Modified:
    incubator/celix/trunk/framework/private/include/bundle_private.h
    incubator/celix/trunk/framework/private/include/framework_private.h
    incubator/celix/trunk/framework/private/src/bundle.c
    incubator/celix/trunk/framework/private/src/framework.c
    incubator/celix/trunk/framework/private/src/utils.c
    incubator/celix/trunk/framework/public/include/bundle.h
    incubator/celix/trunk/utils/private/src/celix_threads.c
    incubator/celix/trunk/utils/public/include/celix_threads.h

Modified: incubator/celix/trunk/framework/private/include/bundle_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/bundle_private.h?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/bundle_private.h (original)
+++ incubator/celix/trunk/framework/private/include/bundle_private.h Wed Jun  4 13:11:44 2014
@@ -39,9 +39,9 @@ struct bundle {
 	manifest_pt manifest;
 	apr_pool_t *memoryPool;
 
-	apr_thread_mutex_t *lock;
+	celix_thread_mutex_t lock;
 	int lockCount;
-	apr_os_thread_t lockThread;
+	celix_thread_t lockThread;
 
 	struct framework * framework;
 };

Modified: incubator/celix/trunk/framework/private/include/framework_private.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/include/framework_private.h?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/include/framework_private.h (original)
+++ incubator/celix/trunk/framework/private/include/framework_private.h Wed Jun  4 13:11:44
2014
@@ -59,12 +59,12 @@ struct framework {
     struct serviceRegistry * registry;
     bundle_cache_pt cache;
 
-    celix_thread_cond_t *shutdownGate;
-    celix_thread_cond_t *condition;
+    celix_thread_cond_t shutdownGate;
+    celix_thread_cond_t condition;
 
-    celix_thread_mutex_t *installRequestLock;
-    celix_thread_mutex_t *mutex;
-    celix_thread_mutex_t *bundleLock;
+    celix_thread_mutex_t installRequestLock;
+    celix_thread_mutex_t mutex;
+    celix_thread_mutex_t bundleLock;
 
     celix_thread_t globalLockThread;
     array_list_pt globalLockWaitersList;

Modified: incubator/celix/trunk/framework/private/src/bundle.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/bundle.c?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/bundle.c (original)
+++ incubator/celix/trunk/framework/private/src/bundle.c Wed Jun  4 13:11:44 2014
@@ -26,8 +26,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <apr_strings.h>
-#include <apr_portable.h>
-#include <apr_thread_proc.h>
 
 #include "framework_private.h"
 #include "bundle_private.h"
@@ -70,7 +68,7 @@ celix_status_t bundle_create(bundle_pt *
         bundle_addModule(*bundle, module);
         // (*bundle)->module = module;
 
-        apr_status = apr_thread_mutex_create(&(*bundle)->lock, APR_THREAD_MUTEX_UNNESTED,
(*bundle)->memoryPool);
+        apr_status = celixThreadMutex_create(&(*bundle)->lock, NULL);
         if (apr_status != APR_SUCCESS) {
         	status = CELIX_ILLEGAL_STATE;
         } else {
@@ -110,7 +108,7 @@ celix_status_t bundle_createFromArchive(
         apr_status_t apr_status;
 
 		bundle_addModule(*bundle, module);
-        apr_status = apr_thread_mutex_create(&(*bundle)->lock, APR_THREAD_MUTEX_UNNESTED,
(*bundle)->memoryPool);
+        apr_status = celixThreadMutex_create(&(*bundle)->lock, NULL);
         if (apr_status != APR_SUCCESS) {
 			status = CELIX_ILLEGAL_STATE;
 		} else {
@@ -136,7 +134,7 @@ celix_status_t bundle_destroy(bundle_pt 
 	}
 	arrayListIterator_destroy(iter);
 	arrayList_destroy(bundle->modules);
-	apr_thread_mutex_destroy(bundle->lock);
+	celixThreadMutex_destroy(&bundle->lock);
 
 	apr_pool_destroy(bundle->memoryPool);
 	return CELIX_SUCCESS;
@@ -482,7 +480,7 @@ celix_status_t bundle_isLockable(bundle_
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 
-	apr_status = apr_thread_mutex_lock(bundle->lock);
+	apr_status = celixThreadMutex_lock(&bundle->lock);
 	if (apr_status != APR_SUCCESS) {
 		status = CELIX_BUNDLE_EXCEPTION;
 	} else {
@@ -492,7 +490,7 @@ celix_status_t bundle_isLockable(bundle_
 			*lockable = (bundle->lockCount == 0) || (equals);
 		}
 
-		apr_status = apr_thread_mutex_unlock(bundle->lock);
+		apr_status = celixThreadMutex_unlock(&bundle->lock);
 		if (apr_status != APR_SUCCESS) {
 			status = CELIX_BUNDLE_EXCEPTION;
 		}
@@ -503,17 +501,17 @@ celix_status_t bundle_isLockable(bundle_
 	return status;
 }
 
-celix_status_t bundle_getLockingThread(bundle_pt bundle, apr_os_thread_t *thread) {
+celix_status_t bundle_getLockingThread(bundle_pt bundle, celix_thread_t *thread) {
 	celix_status_t status = CELIX_SUCCESS;
 	apr_status_t apr_status;
 
-	apr_status = apr_thread_mutex_lock(bundle->lock);
+	apr_status = celixThreadMutex_lock(&bundle->lock);
 	if (apr_status != APR_SUCCESS) {
 		status = CELIX_BUNDLE_EXCEPTION;
 	} else {
 		*thread = bundle->lockThread;
 
-		apr_status = apr_thread_mutex_unlock(bundle->lock);
+		apr_status = celixThreadMutex_unlock(&bundle->lock);
 		if (apr_status != APR_SUCCESS) {
 			status = CELIX_BUNDLE_EXCEPTION;
 		}
@@ -528,7 +526,7 @@ celix_status_t bundle_lock(bundle_pt bun
 	celix_status_t status = CELIX_SUCCESS;
 	bool equals;
 
-	apr_thread_mutex_lock(bundle->lock);
+	celixThreadMutex_lock(&bundle->lock);
 
 	status = thread_equalsSelf(bundle->lockThread, &equals);
 	if (status == CELIX_SUCCESS) {
@@ -536,12 +534,12 @@ celix_status_t bundle_lock(bundle_pt bun
 			*locked = false;
 		} else {
 			bundle->lockCount++;
-			bundle->lockThread = apr_os_thread_current();
+			bundle->lockThread = celixThread_self();
 			*locked = true;
 		}
 	}
 
-	apr_thread_mutex_unlock(bundle->lock);
+	celixThreadMutex_unlock(&bundle->lock);
 
 	framework_logIfError(bundle->framework->logger, status, NULL, "Failed to lock bundle");
 
@@ -553,7 +551,7 @@ celix_status_t bundle_unlock(bundle_pt b
 
 	bool equals;
 
-	apr_thread_mutex_lock(bundle->lock);
+	celixThreadMutex_lock(&bundle->lock);
 
 	if (bundle->lockCount == 0) {
 		*unlocked = false;
@@ -571,7 +569,7 @@ celix_status_t bundle_unlock(bundle_pt b
 		}
 	}
 
-	apr_thread_mutex_unlock(bundle->lock);
+	celixThreadMutex_unlock(&bundle->lock);
 
 	framework_logIfError(bundle->framework->logger, status, NULL, "Failed to unlock bundle");
 

Modified: incubator/celix/trunk/framework/private/src/framework.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/framework.c?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/framework.c (original)
+++ incubator/celix/trunk/framework/private/src/framework.c Wed Jun  4 13:11:44 2014
@@ -33,8 +33,6 @@
 #include <apr_file_io.h>
 #include <apr_general.h>
 #include <apr_strings.h>
-#include <apr_thread_mutex.h>
-#include <apr_thread_proc.h>
 #include <apr_uuid.h>
 #ifdef _WIN32
 #include <winbase.h>
@@ -202,7 +200,6 @@ celix_status_t framework_create(framewor
             (*framework)->bundleListeners = NULL;
             (*framework)->frameworkListeners = NULL;
             (*framework)->requests = NULL;
-            (*framework)->shutdownGate = NULL;
             (*framework)->configurationMap = config;
             (*framework)->logger = logger;
 
@@ -1811,7 +1808,6 @@ celix_status_t framework_acquireBundleLo
 		bool isSelf = false;
 
 		bundle_isLockable(bundle, &lockable);
-		// #TODO
 		thread_equalsSelf(framework->globalLockThread, &isSelf);
 
 		while (!lockable
@@ -1828,11 +1824,11 @@ celix_status_t framework_acquireBundleLo
 					&& (lockingThread != 0)
 					&& arrayList_contains(framework->globalLockWaitersList, &lockingThread))
{
 				framework->interrupted = true;
-				celixThreadCondition_signal_thread_np(&framework->condition, bundle_getLockingThread(bundle));
-//				celixThreadCondition_signal(framework->condition);
+//				celixThreadCondition_signal_thread_np(&framework->condition, bundle_getLockingThread(bundle));
+				celixThreadCondition_signal(&framework->condition);
 			}
 
-            celixThreadCondition_wait(framework->condition, framework->bundleLock);
+            celixThreadCondition_wait(&framework->condition, &framework->bundleLock);
 
 			status = bundle_isLockable(bundle, &lockable);
 			if (status != CELIX_SUCCESS) {
@@ -1853,7 +1849,7 @@ celix_status_t framework_acquireBundleLo
 				}
 			}
 		}
-		celixThreadMutex_unlock(framework->bundleLock);
+		celixThreadMutex_unlock(&framework->bundleLock);
 	}
 
 	framework_logIfError(framework->logger, status, NULL, "Failed to get bundle lock");
@@ -1865,19 +1861,19 @@ bool framework_releaseBundleLock(framewo
     bool unlocked;
     apr_os_thread_t lockingThread = 0;
 
-    celixThreadMutex_lock(framework->bundleLock);
+    celixThreadMutex_lock(&framework->bundleLock);
 
     bundle_unlock(bundle, &unlocked);
 	if (!unlocked) {
-	    celixThreadMutex_unlock(framework->bundleLock);
+	    celixThreadMutex_unlock(&framework->bundleLock);
 		return false;
 	}
 	bundle_getLockingThread(bundle, &lockingThread);
 	if (lockingThread == 0) {
-	    celixThreadCondition_broadcast(framework->condition);
+	    celixThreadCondition_broadcast(&framework->condition);
 	}
 
-	celixThreadMutex_unlock(framework->bundleLock);
+	celixThreadMutex_unlock(&framework->bundleLock);
 
 	return true;
 }
@@ -1886,7 +1882,7 @@ bool framework_acquireGlobalLock(framewo
     bool interrupted = false;
 	bool isSelf = false;
 
-	celixThreadMutex_lock(framework->bundleLock);
+	celixThreadMutex_lock(&framework->bundleLock);
 
 	thread_equalsSelf(framework->globalLockThread, &isSelf);
 
@@ -1895,9 +1891,9 @@ bool framework_acquireGlobalLock(framewo
 			&& (!isSelf)) {
 		celix_thread_t currentThread = celixThread_self();
 		arrayList_add(framework->globalLockWaitersList, &currentThread);
-		celixThreadCondition_broadcast(framework->condition);
+		celixThreadCondition_broadcast(&framework->condition);
 
-		celixThreadCondition_wait(framework->condition, framework->bundleLock);
+		celixThreadCondition_wait(&framework->condition, &framework->bundleLock);
 		if (framework->interrupted) {
 			interrupted = true;
 			framework->interrupted = false;
@@ -1911,23 +1907,23 @@ bool framework_acquireGlobalLock(framewo
 		framework->globalLockThread = celixThread_self();
 	}
 
-	celixThreadMutex_unlock(framework->bundleLock);
+	celixThreadMutex_unlock(&framework->bundleLock);
 
 	return !interrupted;
 }
 
 celix_status_t framework_releaseGlobalLock(framework_pt framework) {
 	int status = CELIX_SUCCESS;
-	if (celixThreadMutex_lock(framework->bundleLock) != 0) {
+	if (celixThreadMutex_lock(&framework->bundleLock) != 0) {
 		fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error locking framework bundle
lock");
 		return CELIX_FRAMEWORK_EXCEPTION;
 	}
 
-	if (framework->globalLockThread == apr_os_thread_current()) {
+	if (framework->globalLockThread == celixThread_self()) {
 		framework->globalLockCount--;
 		if (framework->globalLockCount == 0) {
 			framework->globalLockThread = 0;
-			if (celixThreadCondition_broadcast(framework->condition) != 0) {
+			if (celixThreadCondition_broadcast(&framework->condition) != 0) {
 				fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Failed to broadcast global lock
release.");
 				status = CELIX_FRAMEWORK_EXCEPTION;
 				// still need to unlock before returning
@@ -1937,7 +1933,7 @@ celix_status_t framework_releaseGlobalLo
 		printf("The current thread does not own the global lock");
 	}
 
-	if (celixThreadMutex_unlock(framework->bundleLock) != 0) {
+	if (celixThreadMutex_unlock(&framework->bundleLock) != 0) {
 		fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error unlocking framework bundle
lock");
 		return CELIX_FRAMEWORK_EXCEPTION;
 	}
@@ -1948,18 +1944,18 @@ celix_status_t framework_releaseGlobalLo
 }
 
 celix_status_t framework_waitForStop(framework_pt framework) {
-	if (celixThreadMutex_lock(framework->mutex) != 0) {
+	if (celixThreadMutex_lock(&framework->mutex) != 0) {
 		fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR, "Error locking the framework, shutdown
gate not set.");
 		return CELIX_FRAMEWORK_EXCEPTION;
 	}
 	while (!framework->shutdown) {
-		apr_status_t apr_status = celixThreadCondition_wait(framework->shutdownGate, framework->mutex);
+		apr_status_t apr_status = celixThreadCondition_wait(&framework->shutdownGate, &framework->mutex);
 		if (apr_status != 0) {
 			fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR, "Error waiting for shutdown gate.");
 			return CELIX_FRAMEWORK_EXCEPTION;
 		}
 	}
-	if (celixThreadMutex_unlock(framework->mutex) != 0) {
+	if (celixThreadMutex_unlock(&framework->mutex) != 0) {
 		fw_log(framework->logger, OSGI_FRAMEWORK_LOG_ERROR, "Error unlocking the framework.");
 		return CELIX_FRAMEWORK_EXCEPTION;
 	}
@@ -1967,8 +1963,7 @@ celix_status_t framework_waitForStop(fra
 	return CELIX_SUCCESS;
 }
 
-static void *APR_THREAD_FUNC framework_shutdown(apr_thread_t *thd, void *framework) {
-//static void * framework_shutdown(void * framework) {
+static void *framework_shutdown(void *framework) {
 	framework_pt fw = (framework_pt) framework;
 	hash_map_iterator_pt iterator;
 	int err;
@@ -1991,17 +1986,17 @@ static void *APR_THREAD_FUNC framework_s
 	}
 	hashMapIterator_destroy(iterator);
 
-	err = celixThreadMutex_lock(fw->mutex);
+	err = celixThreadMutex_lock(&fw->mutex);
 	if (err != 0) {
 		fw_log(fw->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error locking the framework, cannot exit
clean.");
 		celixThread_exit(NULL);
 		return NULL;
 	}
 	fw->shutdown = true;
-	err = celixThreadCondition_broadcast(fw->shutdownGate);
+	err = celixThreadCondition_broadcast(&fw->shutdownGate);
 	if (err != 0) {
 		fw_log(fw->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error waking the shutdown gate, cannot
exit clean.");
-		err = celixThreadMutex_unlock(fw->mutex);
+		err = celixThreadMutex_unlock(&fw->mutex);
 		if (err != 0) {
 			fw_log(fw->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error unlocking the framework, cannot
exit clean.");
 		}
@@ -2009,13 +2004,13 @@ static void *APR_THREAD_FUNC framework_s
 		celixThread_exit(NULL);
 		return NULL;
 	}
-	err = celixThreadMutex_unlock(fw->mutex);
+	err = celixThreadMutex_unlock(&fw->mutex);
 	if (err != 0) {
 		fw_log(fw->logger, OSGI_FRAMEWORK_LOG_ERROR,  "Error unlocking the framework, cannot
exit clean.");
 	}
 
 	fw_log(fw->logger, OSGI_FRAMEWORK_LOG_INFO, "FRAMEWORK: Shutdown done\n");
-	celixThread_exit(thd, APR_SUCCESS);
+	celixThread_exit((void *) CELIX_SUCCESS);
 
 	return NULL;
 }
@@ -2211,7 +2206,7 @@ celix_status_t bundleActivator_stop(void
 	if (bundleContext_getFramework(context, &framework) == CELIX_SUCCESS) {
 
 	    fw_log(framework->logger, OSGI_FRAMEWORK_LOG_INFO, "FRAMEWORK: Start shutdownthread");
-	    if (celixThread_create(&shutdownThread, NULL, framework_shutdown, framework) ==
CELIX_SUCCESS) {
+	    if (celixThread_create(&shutdownThread, NULL, &framework_shutdown, framework)
== CELIX_SUCCESS) {
 //            celixThread_join(&status, shutdownThread);
 	        celixThread_detach(shutdownThread);
 	    } else {

Modified: incubator/celix/trunk/framework/private/src/utils.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/private/src/utils.c?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/private/src/utils.c (original)
+++ incubator/celix/trunk/framework/private/src/utils.c Wed Jun  4 13:11:44 2014
@@ -29,6 +29,7 @@
 
 #include "utils.h"
 #include "celix_log.h"
+#include "celix_threads.h"
 
 unsigned int utils_stringHash(void * string) {
 	char * str = (char *) string;
@@ -86,9 +87,9 @@ char * utils_stringTrim(char * string) {
 celix_status_t thread_equalsSelf(celix_thread_t thread, bool *equals) {
 	celix_status_t status = CELIX_SUCCESS;
 
-	apr_os_thread_t self = apr_os_thread_current();
+	celix_thread_t self = celixThread_self();
 	if (status == CELIX_SUCCESS) {
-		*equals = apr_os_thread_equal(self, thread);
+		*equals = celixThread_equals(self, thread);
 	}
 
 	return status;

Modified: incubator/celix/trunk/framework/public/include/bundle.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/framework/public/include/bundle.h?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/framework/public/include/bundle.h (original)
+++ incubator/celix/trunk/framework/public/include/bundle.h Wed Jun  4 13:11:44 2014
@@ -28,7 +28,6 @@
 #define BUNDLE_H_
 
 #include <apr_general.h>
-#include <apr_portable.h>
 
 typedef struct bundle * bundle_pt;
 
@@ -41,6 +40,7 @@ typedef struct bundle * bundle_pt;
 #include "service_reference.h"
 #include "bundle_context.h"
 #include "celix_log.h"
+#include "celix_threads.h"
 
 FRAMEWORK_EXPORT celix_status_t bundle_create(bundle_pt * bundle, framework_logger_pt logger,
apr_pool_t *mp);
 FRAMEWORK_EXPORT celix_status_t bundle_createFromArchive(bundle_pt * bundle, framework_pt
framework, bundle_archive_pt archive, apr_pool_t *bundlePool);
@@ -82,7 +82,7 @@ FRAMEWORK_EXPORT int compareTo(service_r
 
 FRAMEWORK_EXPORT celix_status_t bundle_getState(bundle_pt bundle, bundle_state_e *state);
 FRAMEWORK_EXPORT celix_status_t bundle_isLockable(bundle_pt bundle, bool *lockable);
-FRAMEWORK_EXPORT celix_status_t bundle_getLockingThread(bundle_pt bundle, apr_os_thread_t
*thread);
+FRAMEWORK_EXPORT celix_status_t bundle_getLockingThread(bundle_pt bundle, celix_thread_t
*thread);
 FRAMEWORK_EXPORT celix_status_t bundle_lock(bundle_pt bundle, bool *locked);
 FRAMEWORK_EXPORT celix_status_t bundle_unlock(bundle_pt bundle, bool *unlocked);
 

Modified: incubator/celix/trunk/utils/private/src/celix_threads.c
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/private/src/celix_threads.c?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/utils/private/src/celix_threads.c (original)
+++ incubator/celix/trunk/utils/private/src/celix_threads.c Wed Jun  4 13:11:44 2014
@@ -40,7 +40,7 @@ celix_status_t celixThread_detach(celix_
     return pthread_detach(thread);
 }
 
-celix_status_t celixThread_detach(celix_thread_t thread, void **status) {
+celix_status_t celixThread_join(celix_thread_t thread, void **status) {
     return pthread_join(thread, status);
 }
 
@@ -48,10 +48,18 @@ celix_thread_t celixThread_self() {
     return pthread_self();
 }
 
+int celixThread_equals(celix_thread_t thread1, celix_thread_t thread2) {
+    return pthread_equal(thread1, thread2);
+}
+
 celix_status_t celixThreadMutex_create(celix_thread_mutex_t *mutex, celix_thread_mutexattr_t
*attr) {
     return pthread_mutex_init(mutex, attr);
 }
 
+celix_status_t celixThreadMutex_destroy(celix_thread_mutex_t *mutex) {
+    return pthread_mutex_destroy(mutex);
+}
+
 celix_status_t celixThreadMutex_lock(celix_thread_mutex_t *mutex) {
     return pthread_mutex_lock(mutex);
 }
@@ -76,6 +84,6 @@ celix_status_t celixThreadCondition_sign
     return pthread_cond_signal(cond);
 }
 
-celix_status_t celixThreadCondition_signalThreadNp(celix_thread_cond_t *cond, celix_thread_t
*thread) {
+celix_status_t celixThreadCondition_signalThreadNp(celix_thread_cond_t *cond, celix_thread_t
thread) {
     return pthread_cond_signal_thread_np(cond, thread);
 }

Modified: incubator/celix/trunk/utils/public/include/celix_threads.h
URL: http://svn.apache.org/viewvc/incubator/celix/trunk/utils/public/include/celix_threads.h?rev=1600183&r1=1600182&r2=1600183&view=diff
==============================================================================
--- incubator/celix/trunk/utils/public/include/celix_threads.h (original)
+++ incubator/celix/trunk/utils/public/include/celix_threads.h Wed Jun  4 13:11:44 2014
@@ -39,13 +39,15 @@ typedef void *(*celix_thread_start_t)(vo
 celix_status_t celixThread_create(celix_thread_t *new_thread, celix_thread_attr_t *attr,
celix_thread_start_t func, void *data);
 celix_status_t celixThread_exit(void *exitStatus);
 celix_status_t celixThread_detach(celix_thread_t thread);
-celix_status_t celixThread_detach(celix_thread_t thread, void **status);
+celix_status_t celixThread_join(celix_thread_t thread, void **status);
 celix_thread_t celixThread_self();
+int celixThread_equals(celix_thread_t thread1, celix_thread_t thread2);
 
 typedef pthread_mutex_t celix_thread_mutex_t;
 typedef pthread_mutexattr_t celix_thread_mutexattr_t;
 
 celix_status_t celixThreadMutex_create(celix_thread_mutex_t *mutex, celix_thread_mutexattr_t
*attr);
+celix_status_t celixThreadMutex_destroy(celix_thread_mutex_t *mutex);
 celix_status_t celixThreadMutex_lock(celix_thread_mutex_t *mutex);
 celix_status_t celixThreadMutex_unlock(celix_thread_mutex_t *mutex);
 
@@ -56,6 +58,6 @@ celix_status_t celixThreadCondition_init
 celix_status_t celixThreadCondition_wait(celix_thread_cond_t *cond, celix_thread_mutex_t
*mutex);
 celix_status_t celixThreadCondition_broadcast(celix_thread_cond_t *cond);
 celix_status_t celixThreadCondition_signal(celix_thread_cond_t *cond);
-celix_status_t celixThreadCondition_signalThreadNp(celix_thread_cond_t *cond, celix_thread_t
*thread);
+celix_status_t celixThreadCondition_signalThreadNp(celix_thread_cond_t *cond, celix_thread_t
thread);
 
 #endif /* CELIX_THREADS_H_ */



Mime
View raw message