updt: renamed everything to be under 'mt_' namespace

iamsubhranil · iamsubhranil · commit b1211e3a6b01 · 2021-03-02T14:53:20.000+05:30
diff --git a/README.md b/README.md
@@ -2,10 +2,10 @@
 ### A fast, small, efficient threadpool in c
 This threadpool implementation is much faster, and much feature rich than other notable threadpool implementations found in GitHub. This threadpool has a very small footprint, and can be extensible upto hundreds of threads. 
 ##### Features :
-1. Small initialization cost. When the function `createPool` returns, it is also guaranteed that all threads are fully initialized and in waiting state.
-2. Add hundreds of jobs, asynchronously. The function `addJobToPool` is implemented to guarantee consistency and fast response.
-3. Dynamically add and/or remove threads at runtime. You can add as many threads as you want using `addThreadsToPool` function, or remove a thread using `removeThreadFromPool` function, AT RUNTIME. Just remember, for these functions to work properly, the worker function needs to be as atomic as possible. No threads will be removed if all threads are presently busy. Also, to feel the effect of the new thread, there must be some work to be done.
-4. Easy suspend and resume. You can suspend the pool anytime using `suspendPool`, and resume where you left off using `resumePool`.
+1. Small initialization cost. When the function `mt_create_pool` returns, it is also guaranteed that all threads are fully initialized and in waiting state.
+2. Add hundreds of jobs, asynchronously. The function `mt_add_job` is implemented to guarantee consistency and fast response.
+3. Dynamically add and/or remove threads at runtime. You can add as many threads as you want using `mt_add_thread` function, or remove a thread using `mt_remove_thread` function, AT RUNTIME. Just remember, for these functions to work properly, the worker function needs to be as atomic as possible. No threads will be removed if all threads are presently busy. Also, to feel the effect of the new thread, there must be some work to be done.
+4. Easy suspend and resume. You can suspend the pool anytime using `mt_suspend`, and resume where you left off using `mt_resume`.
 5. Flexible stopping. You can stop the pool in two ways : a) Stop recieving new jobs, but continue existing jobs and then exit and b) Stop recieving new jobs, and exit as immediately as possible. Remeber, for the latter function to work, the work needs to be atomic. No threads will be force stopped if it is currently executing a function.
 ##### Proposed additions :
 1. Implement force-stop [Low priority]
diff --git a/mytest.c b/mytest.c
@@ -28,11 +28,11 @@ int main() {
 	uint64_t size;
 	printf("\nEnter the number of threads to start from : ");
 	scanf("%" SCNu64, &size);
-	ThreadPool *pool = createPool(size);
+	ThreadPool *pool = mt_create_pool(size);
 	printf("\nEnter number of jobs : ");
 	scanf("%" SCNu64, &size);
 	uint64_t i = 0;
-	for(i = 0; i < size; i++) addJobToPool(pool, &longJob, NULL);
+	for(i = 0; i < size; i++) mt_add_job(pool, &longJob, NULL);
 	char choice = '1';
 	while(choice >= '0' && choice < '9') {
 		printf("\n[CHOICE:0] Add some jobs");
@@ -50,22 +50,22 @@ int main() {
 			case '0':
 				printf("\n[CHOICE:INPUT] Number of jobs : ");
 				scanf("%" SCNu64, &size);
-				for(i = 0; i < size; i++) addJobToPool(pool, &longJob, NULL);
+				for(i = 0; i < size; i++) mt_add_job(pool, &longJob, NULL);
 				break;
 			case '1':
 				printf("\n[CHOICE:INFO] Pending jobs %" PRIu64,
-				       getJobCount(pool));
+				       mt_get_job_count(pool));
 				break;
-			case '2': addThreadsToPool(pool, 1); break;
-			case '3': removeThreadFromPool(pool); break;
+			case '2': mt_add_thread(pool, 1); break;
+			case '3': mt_remove_thread(pool); break;
 			case '4':
 				printf("\n[CHOICE:INFO] Number of threads %" PRIu64,
-				       getThreadCount(pool));
+				       mt_get_thread_count(pool));
 				break;
-			case '5': waitToComplete(pool); break;
-			case '6': suspendPool(pool); break;
-			case '7': resumePool(pool); break;
-			case '8': destroyPool(pool); return 0;
+			case '5': mt_join(pool); break;
+			case '6': mt_suspend(pool); break;
+			case '7': mt_resume(pool); break;
+			case '8': mt_destroy_pool(pool); return 0;
 			default: break;
 		}
 	}
diff --git a/mythreads.c b/mythreads.c
@@ -333,7 +333,7 @@ static void *threadExecutor(void *pl) {
 /* This method adds 'threads' number of new threads
  * to the argument pool. See header for more details.
  */
-ThreadPoolStatus addThreadsToPool(ThreadPool *pool, uint64_t threads) {
+ThreadPoolStatus mt_add_thread(ThreadPool *pool, uint64_t threads) {
 	if(pool == NULL) { // Sanity check
 		printf("\n[THREADPOOL:ADD:ERROR] Pool is not initialized!");
 		return POOL_NOT_INITIALIZED;
@@ -397,7 +397,7 @@ ThreadPoolStatus addThreadsToPool(ThreadPool *pool, uint64_t threads) {
 /* This method removes one thread from the
  * argument pool. See header for more details.
  */
-void removeThreadFromPool(ThreadPool *pool) {
+void mt_remove_thread(ThreadPool *pool) {
 	if(pool == NULL || !pool->isInitialized) {
 		printf("\n[THREADPOOL:REM:ERROR] Pool is not initialized!");
 		return;
@@ -433,7 +433,7 @@ void removeThreadFromPool(ThreadPool *pool) {
  * details.
  */
 
-ThreadPool *createPool(uint64_t numThreads) {
+ThreadPool *mt_create_pool(uint64_t numThreads) {
 	ThreadPool *pool = (ThreadPool *)malloc(
 	    sizeof(ThreadPool)); // Allocate memory for the pool
 	if(pool == NULL) {       // Oops!
@@ -489,7 +489,7 @@ ThreadPool *createPool(uint64_t numThreads) {
 		printf("\n[THREADPOOL:INIT:WARNING] Starting with no threads!");
 		pool->isInitialized = 1;
 	} else {
-		addThreadsToPool(pool, numThreads); // Add threads to the pool
+		mt_add_thread(pool, numThreads); // Add threads to the pool
 #ifdef DEBUG
 		printf("\n[THREADPOOL:INIT:INFO] Waiting for all threads to start..");
 #endif
@@ -509,7 +509,7 @@ ThreadPool *createPool(uint64_t numThreads) {
  * details.
  *
  */
-ThreadPoolStatus addJobToPool(ThreadPool *pool, void (*func)(void *args),
+ThreadPoolStatus mt_add_job(ThreadPool *pool, void (*func)(void *args),
                               void *      args) {
 	if(pool == NULL || !pool->isInitialized) { // Sanity check
 		printf("\n[THREADPOOL:EXEC:ERROR] Pool is not initialized!");
@@ -588,7 +588,7 @@ ThreadPoolStatus addJobToPool(ThreadPool *pool, void (*func)(void *args),
 /* Wait for the pool to finish executing. See header
  * for more details.
  */
-void waitToComplete(ThreadPool *pool) {
+void mt_join(ThreadPool *pool) {
 	if(pool == NULL || !pool->isInitialized) { // Sanity check
 		printf("\n[THREADPOOL:WAIT:ERROR] Pool is not initialized!");
 		return;
@@ -626,7 +626,7 @@ void waitToComplete(ThreadPool *pool) {
 /* Suspend all active threads in a pool. See header
  * for more details.
  */
-void suspendPool(ThreadPool *pool) {
+void mt_suspend(ThreadPool *pool) {
 	if(pool == NULL || !pool->isInitialized) { // Sanity check
 		printf("\n[THREADPOOL:SUSP:ERROR] Pool is not initialized!");
 		return;
@@ -660,7 +660,7 @@ void suspendPool(ThreadPool *pool) {
 /* Resume a suspended pool. See header for more
  * details.
  */
-void resumePool(ThreadPool *pool) {
+void mt_resume(ThreadPool *pool) {
 	if(pool == NULL || !pool->isInitialized) { // Sanity check
 		printf("\n[THREADPOOL:RESM:ERROR] Pool is not initialized!");
 		return;
@@ -692,21 +692,21 @@ void resumePool(ThreadPool *pool) {
 /* Returns number of pending jobs in the pool. See
  * header for more details
  */
-uint64_t getJobCount(ThreadPool *pool) {
+uint64_t mt_get_job_count(ThreadPool *pool) {
 	return pool->jobCount;
 }
 
 /* Returns the number of threads in the pool. See
  * header for more details.
  */
-uint64_t getThreadCount(ThreadPool *pool) {
+uint64_t mt_get_thread_count(ThreadPool *pool) {
 	return pool->numThreads;
 }
 
 /* Destroy the pool. See header for more details.
  *
  */
-void destroyPool(ThreadPool *pool) {
+void mt_destroy_pool(ThreadPool *pool) {
 	if(pool == NULL || !pool->isInitialized) { // Sanity check
 		printf("\n[THREADPOOL:EXIT:ERROR] Pool is not initialized!");
 		return;
diff --git a/mythreads.h b/mythreads.h
@@ -58,14 +58,14 @@ typedef enum Status {
  * in case of insufficient memory, which is rare, and a NULL
  * is returned in that case.
  */
-ThreadPool *createPool(uint64_t);
+ThreadPool *mt_create_pool(uint64_t);
 
 /* Waits till all the threads in the pool are finished.
  *
  * When this method returns, it is assured that all threads
  * in the pool have finished executing, and in waiting state.
  */
-void waitToComplete(ThreadPool *);
+void mt_join(ThreadPool *);
 
 /* Destroys the argument pool.
  *
@@ -80,7 +80,7 @@ void waitToComplete(ThreadPool *);
  * threads, destroys all synchronization objects, and frees
  * any remaining jobs, finally freeing the pool itself.
  */
-void destroyPool(ThreadPool *);
+void mt_destroy_pool(ThreadPool *);
 
 /* Add a new job to the pool.
  *
@@ -96,7 +96,7 @@ void destroyPool(ThreadPool *);
  * When all threads are idle, any one of them wakes up and
  * executes this function asynchronously.
  */
-ThreadPoolStatus addJobToPool(ThreadPool *, void (*func)(void *), void *);
+ThreadPoolStatus mt_add_job(ThreadPool *, void (*func)(void *), void *);
 
 /* Add some new threads to the pool.
  *
@@ -111,7 +111,7 @@ ThreadPoolStatus addJobToPool(ThreadPool *, void (*func)(void *), void *);
  * pthread_create, or for insufficient memory. These error
  * codes can be compared using the Status enum above.
  */
-ThreadPoolStatus addThreadsToPool(ThreadPool *, uint64_t);
+ThreadPoolStatus mt_add_thread(ThreadPool *, uint64_t);
 
 /* Suspend all currently executing threads in the pool.
  *
@@ -123,7 +123,7 @@ ThreadPoolStatus addThreadsToPool(ThreadPool *, uint64_t);
  * till the thread completes the present job, and then
  * halts the thread.
  */
-void suspendPool(ThreadPool *);
+void mt_suspend(ThreadPool *);
 
 /* Resume a suspended pool.
  *
@@ -133,7 +133,7 @@ void suspendPool(ThreadPool *);
  * wake up from suspend very soon in future. This method
  * fails if the pool was not previously suspended.
  */
-void resumePool(ThreadPool *);
+void mt_resume(ThreadPool *);
 
 /* Remove an existing thread from the pool.
  *
@@ -153,7 +153,7 @@ void resumePool(ThreadPool *);
  * the pool, the queue will automatically resume from the
  * position where it stopped.
  */
-void removeThreadFromPool(ThreadPool *);
+void mt_remove_thread(ThreadPool *);
 
 /* Returns the number of pending jobs in the pool.
  *
@@ -163,7 +163,7 @@ void removeThreadFromPool(ThreadPool *);
  * idlement if no new jobs are added to the pool from this
  * instant.
  */
-uint64_t getJobCount(ThreadPool *pool);
+uint64_t mt_get_job_count(ThreadPool *pool);
 
 /* Returns the number of threads present in the pool.
  *
@@ -173,6 +173,6 @@ uint64_t getJobCount(ThreadPool *pool);
  * executing a worker function or in idle wait, will be
  * returned by this method.
  */
-uint64_t getThreadCount(ThreadPool *);
+uint64_t mt_get_thread_count(ThreadPool *);
 
 #endif
