Remove uncessary use of PTHREAD_CREATE_JOINABLE in test code. NFC. (#12404)

sbc100 · web-flow · commit 09d80521f566 · 2020-10-02T11:14:57.000-07:00
Threads are joinable by default, there is no need to set
this attribute.
diff --git a/system/lib/pthread/library_pthread.c b/system/lib/pthread/library_pthread.c
@@ -938,7 +938,6 @@ int proxy_main(int argc, char** argv) {
   if (emscripten_has_threading_support()) {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
     // Use TOTAL_STACK for the stack size, which is the normal size of the stack
     // that main() would have without PROXY_TO_PTHREAD.
     pthread_attr_setstacksize(&attr, EM_ASM_INT({ return TOTAL_STACK }));
diff --git a/tests/core/pthread/create.cpp b/tests/core/pthread/create.cpp
@@ -30,13 +30,9 @@ pthread_t thread[NUM_THREADS];
 
 void CreateThread(int i)
 {
-  pthread_attr_t attr;
-  pthread_attr_init(&attr);
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
   static int counter = 1;
-  int rc = pthread_create(&thread[i], &attr, ThreadMain, (void*)i);
+  int rc = pthread_create(&thread[i], nullptr, ThreadMain, (void*)i);
   assert(rc == 0);
-  pthread_attr_destroy(&attr);
 }
 
 void mainn() {
diff --git a/tests/gl_in_pthread.cpp b/tests/gl_in_pthread.cpp
@@ -67,7 +67,6 @@ void CreateThread()
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   emscripten_pthread_attr_settransferredcanvases(&attr, "#canvas");
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
   int rc = pthread_create(&thread, &attr, ThreadMain, 0);
   if (rc == ENOSYS)
   {
diff --git a/tests/gl_in_two_pthreads.cpp b/tests/gl_in_two_pthreads.cpp
@@ -51,7 +51,6 @@ void run_thread(int param)
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   emscripten_pthread_attr_settransferredcanvases(&attr, "#canvas");
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
   pthread_t thread;
   int rc = pthread_create(&thread, &attr, thread_main, (void*)param);
   assert(rc == 0);
diff --git a/tests/pthread/test_pthread_64bit_atomics.cpp b/tests/pthread/test_pthread_64bit_atomics.cpp
@@ -91,7 +91,6 @@ void RunTest(int test)
 {	
 	pthread_attr_t attr;
 	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 	pthread_attr_setstacksize(&attr, 4*1024);
 
 	printf("Main thread has thread ID %d\n", (int)pthread_self());
diff --git a/tests/pthread/test_pthread_atomics.cpp b/tests/pthread/test_pthread_atomics.cpp
@@ -103,7 +103,6 @@ void RunTest(int test)
 {	
 	pthread_attr_t attr;
 	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 	pthread_attr_setstacksize(&attr, 4*1024);
 
 	printf("Main thread has thread ID %d\n", (int)pthread_self());
diff --git a/tests/pthread/test_pthread_attr_getstack.cpp b/tests/pthread/test_pthread_attr_getstack.cpp
@@ -52,14 +52,10 @@ int main()
 	}
 
 	pthread_t thread;
-	pthread_attr_t attr;
 	int rc, result;
 
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-	rc = pthread_create(&thread, &attr, ThreadMain, NULL);
+	rc = pthread_create(&thread, NULL, ThreadMain, NULL);
 	assert(rc == 0);
-	pthread_attr_destroy(&attr);
 
 	rc = pthread_join(thread, (void**)&result);
 	assert(rc == 0);
diff --git a/tests/pthread/test_pthread_condition_variable.cpp b/tests/pthread/test_pthread_condition_variable.cpp
@@ -80,18 +80,15 @@ int main (int argc, char *argv[])
   int i, rc;
   long t1=1, t2=2, t3=3;
   pthread_t threads[3];
-  pthread_attr_t attr;
 
   /* Initialize mutex and condition variable objects */
   pthread_mutex_init(&count_mutex, NULL);
   pthread_cond_init (&count_threshold_cv, NULL);
 
   /* For portability, explicitly create threads in a joinable state */
-  pthread_attr_init(&attr);
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-  pthread_create(&threads[0], &attr, watch_count, (void *)t1);
-  pthread_create(&threads[1], &attr, inc_count, (void *)t2);
-  pthread_create(&threads[2], &attr, inc_count, (void *)t3);
+  pthread_create(&threads[0], NULL, watch_count, (void *)t1);
+  pthread_create(&threads[1], NULL, inc_count, (void *)t2);
+  pthread_create(&threads[2], NULL, inc_count, (void *)t3);
 
   if (emscripten_has_threading_support())
   {
@@ -103,7 +100,6 @@ int main (int argc, char *argv[])
   }
 
   /* Clean up and exit */
-  pthread_attr_destroy(&attr);
   pthread_mutex_destroy(&count_mutex);
   pthread_cond_destroy(&count_threshold_cv);
 #ifdef REPORT_RESULT
diff --git a/tests/pthread/test_pthread_create.cpp b/tests/pthread/test_pthread_create.cpp
@@ -61,15 +61,11 @@ int numThreadsToCreate = 1000;
 
 void CreateThread(int i)
 {
-	pthread_attr_t attr;
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 	static int counter = 1;
 	global_shared_data[i] = (counter++ * 12141231) & 0x7FFFFFFF; // Arbitrary random'ish data for perturbing the sort for this thread task.
 //	EM_ASM(out('Main: Creating thread idx ' + $0 + ' (param ' + $1 + ')'), i, global_shared_data[i]);
-	int rc = pthread_create(&thread[i], &attr, ThreadMain, (void*)i);
+	int rc = pthread_create(&thread[i], NULL, ThreadMain, (void*)i);
 	assert(rc == 0);
-	pthread_attr_destroy(&attr);
 }
 
 int main()
diff --git a/tests/pthread/test_pthread_gcc_spinlock.cpp b/tests/pthread/test_pthread_gcc_spinlock.cpp
@@ -60,13 +60,9 @@ int main()
 
 	for(int i = 0; i < NUM_THREADS; ++i)
 	{
-		pthread_attr_t attr;
-		pthread_attr_init(&attr);
-		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-		int rc = pthread_create(&thread[i], &attr, ThreadMain, 0);
+		int rc = pthread_create(&thread[i], NULL, ThreadMain, 0);
 		if (rc != 0 || thread[i] == 0)
 			printf("Failed to create thread!\n");
-		pthread_attr_destroy(&attr);
 	}
 
 	for(int i = 0; i < NUM_THREADS; ++i)
diff --git a/tests/pthread/test_pthread_hardware_concurrency.cpp b/tests/pthread/test_pthread_hardware_concurrency.cpp
@@ -36,7 +36,6 @@ void RunTest(int test)
 
 	pthread_attr_t attr;
 	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 	pthread_attr_setstacksize(&attr, 4*1024);
 
 	printf("Main thread has thread ID %d\n", (int)pthread_self());
diff --git a/tests/pthread/test_pthread_mandelbrot.cpp b/tests/pthread/test_pthread_mandelbrot.cpp
@@ -585,12 +585,8 @@ int main(int argc, char** argv)
   maxThreadsRunning = emscripten_num_logical_cores() < MAX_NUM_THREADS ? emscripten_num_logical_cores() : MAX_NUM_THREADS;
   for(int i = 0; i < maxThreadsRunning; ++i)
   {
-    pthread_attr_t attr;
-    pthread_attr_init(&attr);
-    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-    int rc = pthread_create(&thread[i], &attr, mandelbrot_thread, (void*)i);
+    int rc = pthread_create(&thread[i], NULL, mandelbrot_thread, (void*)i);
     assert(rc == 0);
-    pthread_attr_destroy(&attr);
   }
 #endif
 
diff --git a/tests/pthread/test_pthread_mutex.cpp b/tests/pthread/test_pthread_mutex.cpp
@@ -47,7 +47,6 @@ void CreateThread(int i, int n)
 {
 	pthread_attr_t attr;
 	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 	pthread_attr_setstacksize(&attr, 4*1024);
 	int rc = pthread_create(&thread[i], &attr, ThreadMain, 0);
 	if (rc != 0 || thread[i] == 0)
diff --git a/tests/pthread/test_pthread_proxying_in_futex_wait.cpp b/tests/pthread/test_pthread_proxying_in_futex_wait.cpp
@@ -42,10 +42,7 @@ int main()
 	}
 
 	pthread_t thread;
-	pthread_attr_t attr;
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-	int rc = pthread_create(&thread, &attr, ThreadMain, 0);
+	int rc = pthread_create(&thread, NULL, ThreadMain, 0);
 	assert(rc == 0);
 	rc = emscripten_futex_wait(&main_thread_wait_val, 1, 15 * 1000);
 	// An rc of 0 means no error, and of EWOULDBLOCK means that the value is
@@ -60,7 +57,6 @@ int main()
 #endif
 		exit(1);
 	}
-	pthread_attr_destroy(&attr);
 	pthread_join(thread, 0);		
 
 #ifdef REPORT_RESULT
diff --git a/tests/pthread/test_pthread_run_on_main_thread.cpp b/tests/pthread/test_pthread_run_on_main_thread.cpp
@@ -147,11 +147,8 @@ int main()
 		test_sync();
 		test_async_waitable();
 
-		pthread_attr_t attr;
-		pthread_attr_init(&attr);
-		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 		pthread_t thread;
-		int rc = pthread_create(&thread, &attr, thread_main, 0);
+		int rc = pthread_create(&thread, NULL, thread_main, NULL);
 		assert(rc == 0);
 		rc = pthread_join(thread, 0);
 		assert(rc == 0);
diff --git a/tests/pthread/test_pthread_run_on_main_thread_flood.cpp b/tests/pthread/test_pthread_run_on_main_thread_flood.cpp
@@ -71,11 +71,8 @@ int main()
 		test_sync();
 		test_async_waitable();
 
-		pthread_attr_t attr;
-		pthread_attr_init(&attr);
-		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 		pthread_t thread;
-		int rc = pthread_create(&thread, &attr, thread_main, 0);
+		int rc = pthread_create(&thread, NULL, thread_main, NULL);
 		assert(rc == 0);
 		rc = pthread_join(thread, 0);
 		assert(rc == 0);
diff --git a/tests/pthread/test_pthread_supported.cpp b/tests/pthread/test_pthread_supported.cpp
@@ -13,18 +13,14 @@
 
 void *ThreadMain(void *arg)
 {
-	pthread_exit(0);
+	pthread_exit(NULL);
 }
 
 int main()
 {
 	pthread_t thread;
-	pthread_attr_t attr;
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-	int rc = pthread_create(&thread, &attr, ThreadMain, 0);
-	pthread_attr_destroy(&attr);
-	pthread_join(thread, 0);
+	int rc = pthread_create(&thread, NULL, ThreadMain, NULL);
+	pthread_join(thread, NULL);
 
 	if (emscripten_has_threading_support()) assert(rc == 0);
 	else assert(rc == EAGAIN);
diff --git a/tests/pthread/test_pthread_thread_local_storage.cpp b/tests/pthread/test_pthread_thread_local_storage.cpp
@@ -51,13 +51,9 @@ int numThreadsToCreate = 32;
 
 void CreateThread(int i)
 {
-	pthread_attr_t attr;
-	pthread_attr_init(&attr);
-	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-	int rc = pthread_create(&thread[i], &attr, ThreadMain, (void*)i);
+	int rc = pthread_create(&thread[i], NULL, ThreadMain, (void*)i);
 	if (emscripten_has_threading_support()) assert(rc == 0);
 	else assert(rc == EAGAIN);
-	pthread_attr_destroy(&attr);
 }
 
 int main()

Original file line number	Diff line number	Diff line change
`@@ -30,13 +30,9 @@ pthread_t thread[NUM_THREADS];`
`30`	`30`
`31`	`31`	`void CreateThread(int i)`
`32`	`32`	`{`
`33`		`- pthread_attr_t attr;`
`34`		`- pthread_attr_init(&attr);`
`35`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`36`	`33`	`static int counter = 1;`
`37`		`- int rc = pthread_create(&thread[i], &attr, ThreadMain, (void*)i);`
	`34`	`+ int rc = pthread_create(&thread[i], nullptr, ThreadMain, (void*)i);`
`38`	`35`	`assert(rc == 0);`
`39`		`- pthread_attr_destroy(&attr);`
`40`	`36`	`}`
`41`	`37`
`42`	`38`	`void mainn() {`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,6 @@ void CreateThread()`
`67`	`67`	`pthread_attr_t attr;`
`68`	`68`	`pthread_attr_init(&attr);`
`69`	`69`	`emscripten_pthread_attr_settransferredcanvases(&attr, "#canvas");`
`70`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`71`	`70`	`int rc = pthread_create(&thread, &attr, ThreadMain, 0);`
`72`	`71`	`if (rc == ENOSYS)`
`73`	`72`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,6 @@ void RunTest(int test)`
`91`	`91`	`{`
`92`	`92`	`pthread_attr_t attr;`
`93`	`93`	`pthread_attr_init(&attr);`
`94`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`95`	`94`	`pthread_attr_setstacksize(&attr, 4*1024);`
`96`	`95`
`97`	`96`	`printf("Main thread has thread ID %d\n", (int)pthread_self());`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,6 @@ void RunTest(int test)`
`103`	`103`	`{`
`104`	`104`	`pthread_attr_t attr;`
`105`	`105`	`pthread_attr_init(&attr);`
`106`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`107`	`106`	`pthread_attr_setstacksize(&attr, 4*1024);`
`108`	`107`
`109`	`108`	`printf("Main thread has thread ID %d\n", (int)pthread_self());`
Original file line number	Diff line number	Diff line change
`@@ -60,13 +60,9 @@ int main()`
`60`	`60`
`61`	`61`	`for(int i = 0; i < NUM_THREADS; ++i)`
`62`	`62`	`{`
`63`		`- pthread_attr_t attr;`
`64`		`- pthread_attr_init(&attr);`
`65`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`66`		`- int rc = pthread_create(&thread[i], &attr, ThreadMain, 0);`
	`63`	`+ int rc = pthread_create(&thread[i], NULL, ThreadMain, 0);`
`67`	`64`	`if (rc != 0 \|\| thread[i] == 0)`
`68`	`65`	`printf("Failed to create thread!\n");`
`69`		`- pthread_attr_destroy(&attr);`
`70`	`66`	`}`
`71`	`67`
`72`	`68`	`for(int i = 0; i < NUM_THREADS; ++i)`
Original file line number	Diff line number	Diff line change
`@@ -585,12 +585,8 @@ int main(int argc, char** argv)`
`585`	`585`	`maxThreadsRunning = emscripten_num_logical_cores() < MAX_NUM_THREADS ? emscripten_num_logical_cores() : MAX_NUM_THREADS;`
`586`	`586`	`for(int i = 0; i < maxThreadsRunning; ++i)`
`587`	`587`	`{`
`588`		`- pthread_attr_t attr;`
`589`		`- pthread_attr_init(&attr);`
`590`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`591`		`- int rc = pthread_create(&thread[i], &attr, mandelbrot_thread, (void*)i);`
	`588`	`+ int rc = pthread_create(&thread[i], NULL, mandelbrot_thread, (void*)i);`
`592`	`589`	`assert(rc == 0);`
`593`		`- pthread_attr_destroy(&attr);`
`594`	`590`	`}`
`595`	`591`	`#endif`
`596`	`592`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,6 @@ void CreateThread(int i, int n)`
`47`	`47`	`{`
`48`	`48`	`pthread_attr_t attr;`
`49`	`49`	`pthread_attr_init(&attr);`
`50`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`51`	`50`	`pthread_attr_setstacksize(&attr, 4*1024);`
`52`	`51`	`int rc = pthread_create(&thread[i], &attr, ThreadMain, 0);`
`53`	`52`	`if (rc != 0 \|\| thread[i] == 0)`
Original file line number	Diff line number	Diff line change
`@@ -13,18 +13,14 @@`
`13`	`13`
`14`	`14`	`void ThreadMain(void arg)`
`15`	`15`	`{`
`16`		`- pthread_exit(0);`
	`16`	`+ pthread_exit(NULL);`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`int main()`
`20`	`20`	`{`
`21`	`21`	`pthread_t thread;`
`22`		`- pthread_attr_t attr;`
`23`		`- pthread_attr_init(&attr);`
`24`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`25`		`- int rc = pthread_create(&thread, &attr, ThreadMain, 0);`
`26`		`- pthread_attr_destroy(&attr);`
`27`		`- pthread_join(thread, 0);`
	`22`	`+ int rc = pthread_create(&thread, NULL, ThreadMain, NULL);`
	`23`	`+ pthread_join(thread, NULL);`
`28`	`24`
`29`	`25`	`if (emscripten_has_threading_support()) assert(rc == 0);`
`30`	`26`	`else assert(rc == EAGAIN);`
Original file line number	Diff line number	Diff line change
`@@ -51,13 +51,9 @@ int numThreadsToCreate = 32;`
`51`	`51`
`52`	`52`	`void CreateThread(int i)`
`53`	`53`	`{`
`54`		`- pthread_attr_t attr;`
`55`		`- pthread_attr_init(&attr);`
`56`		`- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);`
`57`		`- int rc = pthread_create(&thread[i], &attr, ThreadMain, (void*)i);`
	`54`	`+ int rc = pthread_create(&thread[i], NULL, ThreadMain, (void*)i);`
`58`	`55`	`if (emscripten_has_threading_support()) assert(rc == 0);`
`59`	`56`	`else assert(rc == EAGAIN);`
`60`		`- pthread_attr_destroy(&attr);`
`61`	`57`	`}`
`62`	`58`
`63`	`59`	`int main()`