maint: update copyright

[gnulib.git] / tests / test-tls.c

diff --git a/tests/test-tls.c b/tests/test-tls.c
index 5a73f72..9eb0b13 100644 (file)
--- a/tests/test-tls.c
+++ b/tests/test-tls.c
@@ -1,5 +1,5 @@
 /* Test of thread-local storage in multithreaded situations.
-   Copyright (C) 2005, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2005, 2008-2014 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -18,7 +18,7 @@
 
 #include <config.h>
 
-#if USE_POSIX_THREADS || USE_SOLARIS_THREADS || USE_PTH_THREADS || USE_WIN32_THREADS
+#if USE_POSIX_THREADS || USE_SOLARIS_THREADS || USE_PTH_THREADS || USE_WINDOWS_THREADS
 
 #if USE_POSIX_THREADS
 # define TEST_POSIX_THREADS 1
@@ -29,8 +29,8 @@
 #if USE_PTH_THREADS
 # define TEST_PTH_THREADS 1
 #endif
-#if USE_WIN32_THREADS
-# define TEST_WIN32_THREADS 1
+#if USE_WINDOWS_THREADS
+# define TEST_WINDOWS_THREADS 1
 #endif
 
 /* Whether to help the scheduler through explicit yield().
@@ -66,7 +66,7 @@
 # define yield()
 #endif
 
-static inline void
+static void
 perhaps_yield (void)
 {
   /* Call yield () only with a certain probability, otherwise with GNU Pth
@@ -89,63 +89,63 @@ worker_thread (void *arg)
   int i, j, repeat;
   unsigned int values[KEYS_COUNT];
 
-  dbgprintf ("Worker %p started\n", gl_thread_self ());
+  dbgprintf ("Worker %p started\n", gl_thread_self_pointer ());
 
   /* Initialize the per-thread storage.  */
   for (i = 0; i < KEYS_COUNT; i++)
     {
-      values[i] = (((unsigned int) rand() >> 3) % 1000000) * THREAD_COUNT + id;
+      values[i] = (((unsigned int) rand () >> 3) % 1000000) * THREAD_COUNT + id;
       /* Hopefully no arithmetic overflow.  */
       if ((values[i] % THREAD_COUNT) != id)
-       abort ();
+        abort ();
     }
   perhaps_yield ();
 
   /* Verify that the initial value is NULL.  */
-  dbgprintf ("Worker %p before initial verify\n", gl_thread_self ());
+  dbgprintf ("Worker %p before initial verify\n", gl_thread_self_pointer ());
   for (i = 0; i < KEYS_COUNT; i++)
     if (gl_tls_get (mykeys[i]) != NULL)
       abort ();
-  dbgprintf ("Worker %p after  initial verify\n", gl_thread_self ());
+  dbgprintf ("Worker %p after  initial verify\n", gl_thread_self_pointer ());
   perhaps_yield ();
 
   /* Initialize the per-thread storage.  */
-  dbgprintf ("Worker %p before first tls_set\n", gl_thread_self ());
+  dbgprintf ("Worker %p before first tls_set\n", gl_thread_self_pointer ());
   for (i = 0; i < KEYS_COUNT; i++)
     {
       unsigned int *ptr = (unsigned int *) malloc (sizeof (unsigned int));
       *ptr = values[i];
       gl_tls_set (mykeys[i], ptr);
     }
-  dbgprintf ("Worker %p after  first tls_set\n", gl_thread_self ());
+  dbgprintf ("Worker %p after  first tls_set\n", gl_thread_self_pointer ());
   perhaps_yield ();
 
   /* Shuffle around the pointers.  */
   for (repeat = REPEAT_COUNT; repeat > 0; repeat--)
     {
-      dbgprintf ("Worker %p doing value swapping\n", gl_thread_self ());
-      i = ((unsigned int) rand() >> 3) % KEYS_COUNT;
-      j = ((unsigned int) rand() >> 3) % KEYS_COUNT;
+      dbgprintf ("Worker %p doing value swapping\n", gl_thread_self_pointer ());
+      i = ((unsigned int) rand () >> 3) % KEYS_COUNT;
+      j = ((unsigned int) rand () >> 3) % KEYS_COUNT;
       if (i != j)
-       {
-         void *vi = gl_tls_get (mykeys[i]);
-         void *vj = gl_tls_get (mykeys[j]);
+        {
+          void *vi = gl_tls_get (mykeys[i]);
+          void *vj = gl_tls_get (mykeys[j]);
 
-         gl_tls_set (mykeys[i], vj);
-         gl_tls_set (mykeys[j], vi);
-       }
+          gl_tls_set (mykeys[i], vj);
+          gl_tls_set (mykeys[j], vi);
+        }
       perhaps_yield ();
     }
 
   /* Verify that all the values are from this thread.  */
-  dbgprintf ("Worker %p before final verify\n", gl_thread_self ());
+  dbgprintf ("Worker %p before final verify\n", gl_thread_self_pointer ());
   for (i = 0; i < KEYS_COUNT; i++)
     if ((*(unsigned int *) gl_tls_get (mykeys[i]) % THREAD_COUNT) != id)
       abort ();
-  dbgprintf ("Worker %p after  final verify\n", gl_thread_self ());
+  dbgprintf ("Worker %p after  final verify\n", gl_thread_self_pointer ());
   perhaps_yield ();
 
-  dbgprintf ("Worker %p dying.\n", gl_thread_self ());
+  dbgprintf ("Worker %p dying.\n", gl_thread_self_pointer ());
   return NULL;
 }
 
@@ -159,22 +159,22 @@ test_tls (void)
       gl_thread_t threads[THREAD_COUNT];
 
       if (pass == 0)
-       for (i = 0; i < KEYS_COUNT; i++)
-         gl_tls_key_init (mykeys[i], free);
+        for (i = 0; i < KEYS_COUNT; i++)
+          gl_tls_key_init (mykeys[i], free);
       else
-       for (i = KEYS_COUNT - 1; i >= 0; i--)
-         gl_tls_key_init (mykeys[i], free);
+        for (i = KEYS_COUNT - 1; i >= 0; i--)
+          gl_tls_key_init (mykeys[i], free);
 
       /* Spawn the threads.  */
       for (i = 0; i < THREAD_COUNT; i++)
-       threads[i] = gl_thread_create (worker_thread, NULL);
+        threads[i] = gl_thread_create (worker_thread, NULL);
 
       /* Wait for the threads to terminate.  */
       for (i = 0; i < THREAD_COUNT; i++)
-       gl_thread_join (threads[i], NULL);
+        gl_thread_join (threads[i], NULL);
 
       for (i = 0; i < KEYS_COUNT; i++)
-       gl_tls_key_destroy (mykeys[i]);
+        gl_tls_key_destroy (mykeys[i]);
     }
 }