Passing argument as int to thread - Warning: cast to pointer from integer different size

Question

What is the difference between passing an argument to pthread_create as int instead of long?

int pthread_create(pthread_t *restrict thread,
          const pthread_attr_t *restrict attr,
          void *(*start_routine)(void*), void *restrict arg);

I took the code from POSIX Threads Programming and it works only declaring the function argument as long

void *PrintHello(void *threadid) {
    long tid;
    tid = (long)threadid;
    printf("Hello World! It's me, thread #%ld!\n", tid);
    pthread_exit(NULL);
} 

int main(int argc, char *argv[]) {
    pthread_t threads[NUM_THREADS];
    int rc;
    long t;
    for(t=0;t<NUM_THREADS;t++){
        printf("In main: creating thread %ld\n", t);
        rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t);
        if (rc){
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }

    /* Last thing that main() should do */
    pthread_exit(NULL);
}

Answer 1

In this case, the issue has nothing to do with threads, but with the conversion between void * and integer types. 'c' allows you to freely convert across these types, but you have to pay attention to the sizes of the objects that you convert.

For example, on x86 in 64-bit mode the size of the void* is 64 bit (8 bytes). It is the same as the size of long int. However, size of int is 32 bits (4 bytes).

So, conversion of an int to (void*) will sign-extend int to 64 bits and assign it to void. Compiler gives you a warning, because sizes in the conversion are different but there is o violation of the standard here.

Conversion back to int from void * will also generate a warning. This conversion will loose upper 32 bits. But it will convert it correctly to int, if the void * itself was assigned from an int. However, if you try to convert it to long and the original int was negative, you will get a completely different picture, it will not be the same as the original int, all upper 32 bits will be a result of the original sign extension.

To make the picture more interesting, it will work differently on different platforms. For example, on 32-bit platforms size of long int could be the same as the size of int and the size of void*.

Potentially size of long int usually matches the size of void*. At least it does for a few platforms. Therefore this conversion is the safest one.

So, the best solution is to avoid such conversions when you write a cross-platform code.

Answer 2

Your are treating the argument as a long rather than a pointer to long. This means you are depending on long and void * to have the same data size. If int has a different size this could explain why it goes wrong. In any case you should pass &t in the argument and extract it accordingly as *threadid:

void *PrintHello(void *threadid) {
    long tid;
    tid = *((long *)threadid); 
    printf("Hello World! It's me, thread #%ld!\n", tid);
    pthread_exit(NULL);
} 

int main(int argc, char *argv[]) {
    pthread_t threads[NUM_THREADS];
    static long tid[NUM_THREADS];
    int rc;
    long t;
    for(t=0; t<NUM_THREADS; t++) {
        printf("In main: creating thread %ld\n", t);
        tid[t] = t;
        rc = pthread_create(&threads[t], NULL, PrintHello, (void *)&tid[t]);
        if(rc) {
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            exit(-1);
        }
    }

    /* Last thing that main() should do */
    pthread_exit(NULL);
}

Update: Store thread IDs in array tid.

Answer 3

the following proposed code:

1. cleanly compiles
2. performs the desired functionality
3. cleans up after itself, even when an error occurs
4. properly (using perror()) outputs the OPs error message AND the text reason the system thinks the error occurred to stderr.
5. uses the signature: int main( void ) so no messages from the compiler about unused parameters.
6. Since a loop counter cannot be < 0, uses variable type size_t for the loop counter.
7. properly initializes (to 0) the pthread_t array to 0 so can be used for cleanup operations
8. Corrects the format specifiers in the calls to printf() to expect a variable with type: size_t
9. Has the main() function properly wait for the threads to exit before the main() function exits
10. incorporates a new function: cleanup() to properly cleanup any threads before exiting the program.
11. uses appropriate horizontal spacing and vertical spacing for readability and ease of understanding.

and now, the proposed code:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define NUM_THREADS 20


void *PrintHello( void *arg ) 
{
    size_t threadNum = (size_t)arg;

    printf( "Hello World! It's me, thread #%lu!\n", threadNum );
    pthread_exit( NULL );
} 



void cleanup( pthread_t *threads )
{
    for( size_t i=0; i<NUM_THREADS; i++ )
    {
        if( threads[i] )
        {
            pthread_join( threads[i], NULL );
        }
    }
}


int main( void ) 
{
    pthread_t threads[ NUM_THREADS ] = {0};


    for( size_t t = 0; t < NUM_THREADS; t++ )
    {
        printf( "In main: creating thread %ld\n", t );
        if( pthread_create( &threads[t], NULL, PrintHello, (void *)t ) )
        {
            perror( "pthread_create() failed" );
            cleanup( threads );
            exit( EXIT_FAILURE );
        }
    }

    cleanup( threads );
    /* Last thing that main() should do */
    pthread_exit( NULL );
}

here is the output from a typical run of the proposed code when no errors occur:

In main: creating thread 0
In main: creating thread 1
Hello World! It's me, thread #0!
In main: creating thread 2
In main: creating thread 3
In main: creating thread 4
Hello World! It's me, thread #3!
In main: creating thread 5
Hello World! It's me, thread #4!
In main: creating thread 6
In main: creating thread 7
Hello World! It's me, thread #6!
Hello World! It's me, thread #5!
In main: creating thread 8
Hello World! It's me, thread #7!
In main: creating thread 9
Hello World! It's me, thread #8!
In main: creating thread 10
In main: creating thread 11
In main: creating thread 12
Hello World! It's me, thread #10!
Hello World! It's me, thread #9!
Hello World! It's me, thread #11!
In main: creating thread 13
In main: creating thread 14
Hello World! It's me, thread #13!
In main: creating thread 15
Hello World! It's me, thread #12!
Hello World! It's me, thread #14!
In main: creating thread 16
Hello World! It's me, thread #15!
In main: creating thread 17
In main: creating thread 18
In main: creating thread 19
Hello World! It's me, thread #19!
Hello World! It's me, thread #16!
Hello World! It's me, thread #17!
Hello World! It's me, thread #18!
Hello World! It's me, thread #1!
Hello World! It's me, thread #2!