c, pthread_create gives segmentation fault ?

I'm keep getting a segmentation fault from where I create thread and declare some variables in the struct...

Does anyone know why?

dispatch_queue_t *dispatch_queue_create(queue_type_t queueType){

int cores = num_cores();
printf("message-queuecreate1");

dispatch_queue_t *dispatch_queue = (dispatch_queue_t *) malloc(sizeof(dispatch_queue_t));
dispatch_queue->HEAD = NULL;
dispatch_queue->END = NULL;

//create a thread array for dispatcher and worker threads
dispatch_queue_thread_t *threads[cores+1];
threads[cores+1]= (dispatch_queue_thread_t *)malloc(sizeof(dispatch_queue_thread_t));

//create se开发者_JS百科maphores
sem_t queue_task_semaphore;
sem_t queue_thread_semaphore;
sem_t queue_wait_semaphore;

sem_init(&queue_task_semaphore, 0, 1);
sem_init(&queue_thread_semaphore,0,1);
sem_init(&queue_wait_semaphore,0,1);

dispatch_queue->queue_task_semaphore = queue_task_semaphore;
dispatch_queue->queue_thread_semaphore = queue_thread_semaphore;
dispatch_queue->queue_wait_semaphore = queue_wait_semaphore;




//create dispatcher thread      
//segmentation fault #1////////////////
threads[0]->current_task=NULL;
threads[0]->queue=dispatch_queue;

pthread_create(threads[0]->thread, NULL, dispatcher_threadloop, threads[0]);
//////////////////////////////////////  

if (queueType == CONCURRENT){
    int i = 0;
    int thread_id=0;
    //create worker thread array if the type of the queue is concurrent

    while(i<cores){

        //create worker thread

        thread_id = i+1;

        //segmentation fault #2//////////
        threads[i+1]->queue=dispatch_queue;
        threads[thread_id]->thread=NULL;
        threads[thread_id]->current_task=NULL;

        pthread_create(threads[thread_id]->thread, NULL, worker_threadloop, (void *)(long)i);
        ////////////////////////////////

        printf("thread %d is created\n",i);
        i++;
    }

} else {//do smth}
    //segmentation fault# 3////////////////
    threads[1]->thread=worker_thread;
    threads[1]->queue=dispatch_queue;
    threads[1]->current_task=NULL;
    //////////////////////////////////////
}



return dispatch_queue;

}

Your code is riddled with problems:

Accessing threads[core + 1] is invalid. Also, you're not allocating memory for the threads[0] ... threads[core].

dispatch_queue_thread_t *threads[cores+1];
threads[cores+1]= ....;

So these will fail:

threads[0]->current_task=NULL; /* See above. */

threads[i+1]->queue=dispatch_queue; /* Again, no memory allocated. */

There could be other problems but I would start by slashing the cores+1 stuff and replacing it with:

for (i = 0; i < cores; i++) {
    threads[i] = malloc(sizeof(*threads[i]));
}

Assuming

threads[]->thread 

is a pthread_t (and not a pthread_t *)

You need to give the reference:

pthread_create(&threads[thread_id]->thread, NULL, worker_threadloop, (void *)(long)i);

.