pthread_join error, making threads from threads

Question

I am currently trying to make threads from other threads. When my threads are trying to join, I get a segfault

This is my main function:

int main( int argc, char *argv[] ) {
    std::cout<< "start" << std::endl;
    init();
    std::cout<<"finished init" << std::endl;
    t1=clock();
    pthread_t threads[THREAD_COUNT];

    for (int i = 0; i < THREAD_COUNT; i++) {
        pthread_create(&threads[i], NULL, &threadMain, (void*)((long)i));
    }

    for (int i = 0; i < THREAD_COUNT; i++) {
        printf("joining %d \n" , i);
        pthread_join(threads[i], NULL);
    }
    timeEnd();


    return(0);
}

and my thread main:

void *threadMain(void *arg) {
long thread = (long) arg;

volatile int *tix;
tix = (volatile int *)malloc(sizeof(volatile int) * INNER_THREADS);
volatile int *c;
c =  (volatile int *)malloc(sizeof(volatile int) * INNER_THREADS);
volatile int r;

memset((void*)tix, 0, sizeof(tix));
memset((void*)c, 0, sizeof(c));
r = 0;


pthread_t threads[INNER_THREADS];


for (int i = 0; i < INNER_THREADS; ++i) {
    vec[i+thread*2] = new desc();
    vec[i+thread*2]->outterThread = thread;
    vec[i+thread*2]->innerThread = i;
    vec[i+thread*2]->tix = tix;
    vec[i+thread*2]->c = c;
    vec[i+thread*2]->r = &r;
    pthread_create(&threads[i], NULL, &threadBody, (void*) vec[i+thread*2]);


}

for (int i = 0; i < INNER_THREADS; ++i) {
    pthread_join(threads[i], NULL);
}


return 0;
}

Running valgrind gives me the error:

==820== Thread 288:
==820== Invalid read of size 4
==820==    at 0x387AA08213: pthread_join (in /lib64/libpthread-2.12.so)
==820==    by 0x4019F1: threadMain(void*) (t.c:146)
==820==    by 0x387AA07AA0: start_thread (in /lib64/libpthread-2.12.so)
==820==    by 0x387A2E8AAC: clone (in /lib64/libc-2.12.so)
==820==  Address 0xc29c79d0 is not stack'd, malloc'd or (recently) free'd
==820== 
==820== 
==820== Process terminating with default action of signal 11 (SIGSEGV)
==820==  Access not within mapped region at address 0xC29C79D0
==820==    at 0x387AA08213: pthread_join (in /lib64/libpthread-2.12.so)
==820==    by 0x4019F1: threadMain(void*) (t.c:146)
==820==    by 0x387AA07AA0: start_thread (in /lib64/libpthread-2.12.so)
==820==    by 0x387A2E8AAC: clone (in /lib64/libc-2.12.so)
==820==  If you believe this happened as a result of a stack
==820==  overflow in your program's main thread (unlikely but
==820==  possible), you can try to increase the size of the
==820==  main thread stack using the --main-stacksize= flag.
==820==  The main thread stack size used in this run was 10485760.

Whenever I run it on an ubuntu machine I get a segmentation fault. Using gdb, putting a breakpoint in the pthread_join and stepping through eventually gives me a segfault.

Running it on a mac, I get the following output:

./a.out

start

finished init

joining 0

a.out(3473,0x10c61e000) malloc: * error for object 0x7f97fa5016f0: pointer being freed was not allocated * set a breakpoint in malloc_error_break to debug

Abort trap: 6

EDIT

Some definitions:

#define INNER_THREADS 2
#define THREAD_COUNT 10

struct desc{
  long outterThread;
  long innerThread;
  volatile int* tix;
  volatile int* c;
  volatile int* r;
};

struct desc* vec[THREAD_COUNT*2];

Where are the `free()`s? This looks bad: `vec[i+thread*2]->tix = tix;`: you're making multiple copies of a dynamically allocated memory address; I bet you `free()` it multiple times. — YSC, Feb 09 '17 at 14:50
@YSC I've not free'd them. I need the threads to have their own memory for tix, c and r so their inner threads work with it. — BabblingMonkey, Feb 09 '17 at 14:51
This looks fishy to: `memset((void*)tix, 0, sizeof(tix));`, but unrelated — YSC, Feb 09 '17 at 14:51
How are `THREAD_COUNT`, `INNER_THREADS`, `vec` defined? Please [edit] your question with a [mcve]. — YSC, Feb 09 '17 at 14:56

score 0 · Answer 1 · answered Feb 09 '17 at 15:56

Please complete your program by adding missing details : threadBody(), init(), clock() & timeEnd() or remove them if they are not relevant for the issue faced.

I could prepare code by deleting/assuming some missing details : http://pastebin.com/j5a9whdR

It works fine.

$ ./a.out | sort
joining outer thread 0
joining outer thread 1
joining outer thread 2
joining outer thread 3
joining outer thread 4
joining outer thread 5
joining outer thread 6
joining outer thread 7
joining outer thread 8
joining outer thread 9
Outer thread 0 Inner thread 0
Outer thread 0 Inner thread 1
Outer thread 1 Inner thread 0
Outer thread 1 Inner thread 1
Outer thread 2 Inner thread 0
Outer thread 2 Inner thread 1
Outer thread 3 Inner thread 0
Outer thread 3 Inner thread 1
Outer thread 4 Inner thread 0
Outer thread 4 Inner thread 1
Outer thread 5 Inner thread 0
Outer thread 5 Inner thread 1
Outer thread 6 Inner thread 0
Outer thread 6 Inner thread 1
Outer thread 7 Inner thread 0
Outer thread 7 Inner thread 1
Outer thread 8 Inner thread 0
Outer thread 8 Inner thread 1
Outer thread 9 Inner thread 0
Outer thread 9 Inner thread 1
$

valgrind is happy too except for some memory leaks.

One thing to mention : the usage of '2' (in vec[i+thread*2] and vec[THREAD_COUNT*2]) should be replaced with INNER_THREADS.

The main question is what is in threadBody() function?

in threadBody, I am updating the values in c,r, and tix which all of the inner threads should have access to. — BabblingMonkey, Feb 09 '17 at 16:52

score -2 · Answer 2 · answered Feb 09 '17 at 14:43

-2

long thread = (long) * thread should be used not just "(long) thread . I'm referring to the first line of your threadMain function

answered Feb 09 '17 at 14:43

Aisha Javed

169
13

pthread_join error, making threads from threads

2 Answers2