Changeset 7538


Ignore:
Timestamp:
07/03/18 19:17:31 (3 weeks ago)
Author:
baker
Message:

change assert() to a logit() warning message, remove _USE_PTHREADS conditionals on unix (always _USE_PTHREADS)

Location:
trunk/src/libsrc
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/solaris/threads_ew.c

    r7512 r7538  
    77               ***********************************************/ 
    88 
    9 #include <assert.h>                     /* assert() */ 
    10  
    119#include <signal.h> 
    1210#include <stdio.h> 
     
    1513#include <thread.h> 
    1614 
     15#include "earthworm_simple_funcs.h"     /* logit() */ 
    1716#include "earthworm_complex_funcs.h"    /* Earthworm threads API */ 
    1817 
     
    2827    *                 In OS2, if zero the stack size is set to 8192    * 
    2928    *                 In SOLARIS, this argument is ignored             * 
    30     *     thread_id:  Thread identification number returned to         * 
    31     *                 calling program.                                 * 
     29    *     thread_id:  Opaque thread ID returned to calling program.    * 
     30    *                                                                  * 
     31    *  The function <fun> is not passed any arguments.                 * 
     32    *                                                                  * 
    3233    * Returns:                                                         * 
    3334    *    -1 if error                                                   * 
     
    5657                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    5758   if ( rc != 0 ) 
    58       return( -1 ); 
     59      return -1; 
    5960 
    6061   *thread_id = (unsigned int) tid; 
    6162 
    62    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     63   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     64   logit( "ep", "StartThread: " 
     65                "Warning: thread ID overflows thread_id data type.\n"); 
    6366 
    6467   return 0; 
     
    7578    *                 In OS2, if zero the stack size is set to 8192    * 
    7679    *                 In SOLARIS, this argument is ignored             * 
    77     *     thread_id:  Thread identification number returned to         * 
    78     *                 calling program.                                 * 
     80    *     thread_id:  Opaque thread ID returned to calling program.    * 
     81    *                                                                  * 
    7982    * Returns:                                                         * 
    8083    *    -1 if error                                                   * 
     
    104107                    THR_DETACHED|THR_NEW_LWP, &tid ); 
    105108   if ( rc != 0 ) 
    106       return( -1 ); 
     109      return -1; 
    107110 
    108111   *thread_id = (unsigned int) tid; 
    109112 
    110    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     113   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     114   logit( "ep", "StartThreadWithArg: " 
     115                "Warning: thread ID overflows thread_id data type.\n"); 
    111116 
    112117   return 0; 
     
    127132} 
    128133 
    129    /************************************************************* 
    130     *                        KillThread                         * 
    131     *                Force a thread to exit now.                * 
    132     *                                                           * 
    133     * Argument:                                                 * 
    134     *    tid = id of thread to kill                             * 
    135     *                                                           * 
    136     * Returns:                                                  * 
    137     *     0 if ok                                               * 
    138     *     non-zero value indicates an error                     * 
    139     *************************************************************/ 
     134   /************************************************************ 
     135    *                        KillThread                        * 
     136    *                Force a thread to exit now.               * 
     137    *                                                          * 
     138    * Argument:                                                * 
     139    *    thread_id = Opaque thread id to kill                  * 
     140    *                                                          * 
     141    * Returns:                                                 * 
     142    *     0 if ok                                              * 
     143    *     non-zero value indicates an error                    * 
     144    ************************************************************/ 
    140145 
    141146int KillThread( unsigned int tid ) { 
     
    153158 
    154159int KillSelfThread( void ) { 
    155    thr_exit( (void *)NULL ); 
     160   thr_exit( NULL ); 
    156161   return 0;                     /* well, not really */ 
    157162} 
  • trunk/src/libsrc/unix/threads_ew.c

    r7512 r7538  
    99#define _XOPEN_SOURCE 500 
    1010 
    11 #include <assert.h>                     /* assert() */ 
    12  
    1311#include <signal.h> 
    1412#include <stdio.h> 
     
    1614#include <string.h> 
    1715#include <sys/types.h> 
    18 #ifdef _USE_PTHREADS 
    1916#include <pthread.h> 
    2017#include <sys/param.h> 
    2118#include <unistd.h> 
    22 #else /* Solaris threads */ 
    23 # include <thread.h> 
    24 # define pthread_t thread_t 
    25 # define pthread_kill thr_kill 
    26 # define pthread_exit thr_exit 
    27 # define pthread_self thr_self 
    28 #endif 
    29  
     19 
     20#include "earthworm_simple_funcs.h"     /* logit() */ 
    3021#include "earthworm_complex_funcs.h"    /* Earthworm threads API */ 
    3122 
     
    3627#endif 
    3728 
    38 #ifdef _USE_PTHREADS 
    3929static int setStackSize( char *, pthread_attr_t *, unsigned int ); 
    40 #endif 
    4130 
    4231   /******************************************************************** 
     
    4938    *                 In OS2, if zero the stack size is set to 8192    * 
    5039    *                 In SOLARIS, this argument is ignored             * 
    51     *     thread_id:  Thread identification number returned to         * 
    52     *                 calling program.                                 * 
     40    *     thread_id:  Opaque thread ID returned to calling program.    * 
     41    *                                                                  * 
     42    *  The function <fun> is not passed any arguments.                 * 
     43    *                                                                  * 
    5344    * Returns:                                                         * 
    5445    *    -1 if error                                                   * 
     
    6253   int error;                     /* Function return code */ 
    6354   pthread_t tid;                 /* SendMsg thread id */ 
    64 #ifdef _USE_PTHREADS 
    6555   pthread_attr_t attr; 
    6656   int cclev; 
    67 #else 
    68    size_t stackSize = 0; 
    69 #endif 
    7057 
    7158/* Set up a signal-handling function to be inherited by threads 
     
    8370   ****************/ 
    8471 
    85 #ifdef _USE_PTHREADS 
    8672   /* initialize attribute to defaults (stack_size = implementation dependent, 
    8773        detach state = PTHREAD_CREATE_JOINABLE, scope = PTHREAD_SCOPE_PROCESS, 
     
    9480   if (setStackSize("StartThread", &attr, stack_size) != 0) 
    9581   { 
    96         return (-1); 
     82        return -1; 
    9783   } 
    9884   /* set automatic detachment of thread upon exit */ 
    9985   if ( (error = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) != 0 ) { 
    10086        fprintf(stderr,"StartThread: pthread_attr_setdetachstate error: %s\n",strerror(error)); 
    101         return (-1); 
     87        return -1; 
    10288   } 
    10389   if ( (error = pthread_create( &tid, &attr, fun, NULL )) != 0 ) { 
    10490      fprintf(stderr,"StartThread: pthread_create error: %s\n",strerror(error)); 
    105       return( -1 ); 
     91      return -1; 
    10692   } 
    10793   /* Concurrency is an X/Open extension to POSIX.1c and may not be implemented by 
     
    114100        if ( (error = pthread_setconcurrency(++cclev)) != 0 ) { 
    115101            fprintf(stderr,"StartThread: pthread_setconcurrency error: %s\n",strerror(error)); 
    116             return (-1); 
     102            return -1; 
    117103        } 
    118 #else 
    119    /* Note: THR_DETACHED is required for thr_exit to work. That is, 
    120       a detached thread can truly kill itself without lingering in 
    121       some afterlife, waiting for some other thread to pick up it's exit 
    122       status before it can truly cease to be...*/ 
    123    error = thr_create( NULL, stackSize, fun, NULL, 
    124                     THR_DETACHED|THR_NEW_LWP, &tid ); 
    125    if ( error != 0 ) { 
    126       fprintf(stderr,"StartThread: thr_create error: %s\n",strerror(error)); 
    127       return( -1 ); 
    128    } 
    129 #endif 
    130104 
    131105   *thread_id = (unsigned int) tid; 
    132106 
    133    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     107   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     108   logit( "ep", "StartThread: " 
     109                "Warning: thread ID overflows thread_id data type.\n"); 
    134110 
    135111   return 0; 
     
    146122    *                 In OS2, if zero the stack size is set to 8192    * 
    147123    *                 In SOLARIS, this argument is ignored             * 
    148     *     thread_id:  Thread identification number returned to         * 
    149     *                 calling program.                                 * 
     124    *     thread_id:  Opaque thread ID returned to calling program.    * 
     125    *                                                                  * 
    150126    * Returns:                                                         * 
    151127    *    -1 if error                                                   * 
     
    160136   int error;                    /* Function return code */ 
    161137   pthread_t tid;                /* SendMsg thread id */ 
    162 #ifdef _USE_PTHREADS 
    163138   pthread_attr_t attr; 
    164139   int cclev; 
    165 #else 
    166    size_t stackSize = 0; 
    167 #endif 
    168140 
    169141/* Set up a signal-handling function to be inherited by threads 
     
    180152/* Start the thread 
    181153   ****************/ 
    182 #ifdef _USE_PTHREADS 
    183154   if ( (error = pthread_attr_init(&attr)) != 0 ) { 
    184155        fprintf(stderr,"StartThreadWithArg: pthread_attr_init error: %s\n",strerror(error)); 
    185         return (-1); 
     156        return -1; 
    186157   } 
    187158   /* set stack size within allowable limits */ 
    188159   if (setStackSize("StartThread", &attr, stack_size) != 0) 
    189160   { 
    190         return (-1); 
     161        return -1; 
    191162   } 
    192163   /* set automatic detachment of thread upon exit */ 
    193164   if ( (error = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) != 0 ) { 
    194165        fprintf(stderr,"StartThreadWithArg: pthread_attr_setdetachstate error: %s\n",strerror(error)); 
    195         return (-1); 
     166        return -1; 
    196167   } 
    197168   if ( (error = pthread_create( &tid, &attr, fun, (void *) arg )) != 0 ) { 
    198169      fprintf(stderr,"StartThreadWithArg: pthread_create error: %s\n",strerror(error)); 
    199       return( -1 ); 
     170      return -1; 
    200171   } 
    201172   /* Concurrency is an X/Open extension to POSIX.1c and may not be implemented by 
     
    208179        if ( (error = pthread_setconcurrency(++cclev)) != 0 ) { 
    209180            fprintf(stderr,"StartThreadWithArg: pthread_setconcurrency error: %s\n",strerror(error)); 
    210             return (-1); 
     181            return -1; 
    211182        } 
    212 #else 
    213    /* Note: THR_DETACHED is required for thr_exit to work. That is, 
    214       a detached thread can truly kill itself without lingering in 
    215       some afterlife, waiting for some other thread to pick up it's exit 
    216       status before it can truly cease to be...*/ 
    217    error = thr_create( NULL, stackSize, fun, (void *) arg, 
    218                     THR_DETACHED|THR_NEW_LWP, &tid ); 
    219    if ( error != 0 ) { 
    220       fprintf(stderr,"StartThreadWithArg: thr_create error: %s\n",strerror(error)); 
    221       return( -1 ); 
    222    } 
    223 #endif 
    224183 
    225184   *thread_id = (unsigned int) tid; 
    226185 
    227    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     186   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     187   logit( "ep", "StartThreadWithArg: " 
     188                "Warning: thread ID overflows thread_id data type.\n"); 
    228189 
    229190   return 0; 
     
    244205} 
    245206 
    246    /************************************************************* 
    247     *                        KillThread                         * 
    248     *                Force a thread to exit now.                * 
    249     *                                                           * 
    250     * Argument:                                                 * 
    251     *    tid = id of thread to kill                             * 
    252     *                                                           * 
    253     * Returns:                                                  * 
    254     *     0 if ok                                               * 
    255     *     non-zero value indicates an error                     * 
    256     *************************************************************/ 
     207   /************************************************************ 
     208    *                        KillThread                        * 
     209    *                Force a thread to exit now.               * 
     210    *                                                          * 
     211    * Argument:                                                * 
     212    *    thread_id = Opaque thread id to kill                  * 
     213    *                                                          * 
     214    * Returns:                                                 * 
     215    *     0 if ok                                              * 
     216    *     non-zero value indicates an error                    * 
     217    ************************************************************/ 
    257218 
    258219int KillThread( unsigned int tid ) { 
     
    297258   } 
    298259} 
    299  
    300 #ifdef _USE_PTHREADS 
    301260 
    302261static int setStackSize( char *function_text, 
     
    312271        { 
    313272               fprintf(stderr,"%s: pthread_attr_getstacksize error: %s\n", function_text, strerror(error)); 
    314                return (-1); 
     273               return -1; 
    315274        } 
    316275 
     
    329288           if ( (error = (pthread_attr_setstacksize(pattr, stack_size)) != 0) ) { 
    330289               fprintf(stdout,"%s: pthread_attr_setstacksize (%d) error: %s\n", function_text, stack_size, strerror(error)); 
    331                return (-1); 
     290               return -1; 
    332291           } 
    333292        } 
     
    339298   return 0; 
    340299} 
    341  
    342 #endif 
  • trunk/src/libsrc/winnt/threads_ew.c

    r7512 r7538  
    66              *********************************************/ 
    77 
    8 #include <assert.h>                     /* assert() */ 
    9  
    108#include <windows.h> 
    119#include <process.h> 
    1210 
     11#include "earthworm_simple_funcs.h"     /* logit() */ 
    1312#include "earthworm_complex_funcs.h"    /* Earthworm threads API */ 
    1413 
     
    2524    *                 In Windows NT, if stack_size=0, use the stack    * 
    2625    *                 size of the calling thread.                      * 
    27     *     thread_id:  Thread identification number returned to         * 
    28     *                 calling program.                                 * 
     26    *     thread_id:  Opaque thread ID returned to calling program.    * 
    2927    *                                                                  * 
    3028    *  The function <fun> is not passed any arguments.                 * 
     
    4341   tid = _beginthread( fun, stack_size, NULL ); 
    4442 
    45    if ( tid == -1 )                /* Couldn't create thread */ 
     43   if ( tid == (uintptr_t) -1 )             /* Couldn't create thread */ 
    4644      return -1; 
    4745 
    4846   *thread_id = (unsigned int) tid; 
    4947 
    50    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     48   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     49   logit( "ep", "StartThread: " 
     50                "Warning: thread ID overflows thread_id data type.\n"); 
    5151 
    5252   return 0; 
     
    6666    *                 In Windows NT, if stack_size=0, use the stack    * 
    6767    *                 size of the calling thread.                      * 
    68     *     thread_id:  Thread identification number returned to         * 
    69     *                 calling program.                                 * 
     68    *     thread_id:  Opaque thread ID returned to calling program.    * 
    7069    *                                                                  * 
    7170    *  Returns:                                                        * 
     
    8382   tid = _beginthread( fun, stack_size, arg ); 
    8483 
    85    if ( tid == -1 )                /* Couldn't create thread */ 
     84   if ( tid == (uintptr_t) -1 )             /* Couldn't create thread */ 
    8685      return -1; 
    8786 
    8887   *thread_id = (unsigned int) tid; 
    8988 
    90    assert( *thread_id == tid );         /* Critical on 64-bit systems */ 
     89   if ( *thread_id != tid )             /* Critical on 64-bit systems */ 
     90   logit( "ep", "StartThreadWithArg: " 
     91                "Warning: thread ID overflows thread_id data type.\n"); 
    9192 
    9293   return 0; 
     
    110111   *  This function is used in coaxtoring.c                    * 
    111112   *                                                           * 
    112    *    thread_id = Pointer to thread id                       * 
     113   *    thread_id = Pointer to opaque thread id                * 
    113114   *                                                           * 
    114115   *  Returns:                                                 * 
     
    118119 
    119120int WaitThread( unsigned int *thread_id ) { 
    120    if ( WaitForSingleObject( (HANDLE)(*thread_id), INFINITE ) 
    121                                              == WAIT_FAILED ) 
     121   if ( WaitForSingleObject( (HANDLE) (*thread_id), INFINITE ) 
     122                                              == WAIT_FAILED ) 
    122123      return -1; 
    123124   return 0; 
     
    133134    *                                                          * 
    134135    * Argument:                                                * 
    135     *    tid = id of thread to kill                            * 
     136    *    thread_id = Opaque thread id to kill                  * 
    136137    *                                                          * 
    137138    * Returns:                                                 * 
     
    140141    ************************************************************/ 
    141142 
    142 int KillThread( unsigned int tid ) { 
     143int KillThread( unsigned int thread_id ) { 
    143144 
    144145    const DWORD exit_code = 0; 
    145146 
    146     if ( TerminateThread( (HANDLE)tid, exit_code ) == 0 ) 
     147    if ( TerminateThread( (HANDLE) thread_id, exit_code ) == 0 ) 
    147148       return -1; 
    148149 
Note: See TracChangeset for help on using the changeset viewer.