Сегментация Fault с помощью потоков

Question

Я пытаюсь создать свою собственную библиотеку для использования и планирования потоков.

Система работает так, что вы можете make maximum 100 threads, что делает их «готовыми». а затем есть планировщик, который каждый период времени принимает активный поток, помещает его в готовый список и берет первый ожидающий поток в готовом списке.

Мой тестер создает потоки 500000, и каждый поток создает новый поток и пытается завершить работу. второй поток (первый поток создает) делает то же самое. а третий - только сам.

Это тестер:

void f3() 
{ 
    printf("f3 before terminate\n"); 
    uthread_terminate(uthread_get_tid()); 
    printf("f3 after terminate\n"); 
} 

void f2() 
{ 
    printf("f2 before spawn\n"); 
    uthread_spawn(f3); 
    printf("f2 after spawn\n"); 
    uthread_terminate(uthread_get_tid()); 
    printf("f2 after termination\n"); 
} 

void f1() 
{ 
    printf("f1 before spawn\n"); 
    uthread_spawn(f2); 
    printf("f1 after spawn\n"); 
    uthread_terminate(uthread_get_tid()); 
    printf("f1 after termination\n"); 
} 



int main(int argc, char **argv) 
{ 
    printf("test8:\n--------------\n"); 
    cout << "* Output should be:\n";  
    cout << "--------------\n"; 
    cout << "***1***\n"; 
    cout << "***2***\n"; 
    cout << "Output is:\n"; 
    uthread_init(100); 
    printf("***1***\n"); 
    for (volatile int i=0; i< 50000;++i){ 
     uthread_spawn(f1); 
    } 
    printf("***2***\n"); 

    uthread_terminate(0); 
    return 0; 
} 

В то время как моя программа получает "ошибку сегментации", когда он входит в мой планировщик:

static void scheduler(){ 
DBG(("Schedular ")) 
nQuantum++; 
if (ready.size()!=0){ 
    if (active != NULL){ 
     if (active->getState() == Thread::RUNNING){ 
      active->setState(Thread::READY); 
      ready.push_back(active); 
     } 

     int val = sigsetjmp(*active->getEnv(),1); 
     if (val !=0){ 
      blockTimerSignal(UNBLOCK); 
      return; 
     } 
    } 

    // Set new Active 
    active = ready.front(); 
    DBG(("Active thread Id: %d",active->getTid())) 
    ready.pop_front(); 
    DBG(("Doing pop front on ready list")) 
    DBG(("Number of threads in ready list is - %d",(ready.size()))) 
    active->setQuantums(active->getQuantums()+1); 
    active->setState(Thread::RUNNING); 
    setTimer(); 
    blockTimerSignal(UNBLOCK); 
    DBG(("UNBLOCKED")) 
    siglongjmp(*active->getEnv(),1); 
    DBG(("After siglong jmp")) 
}else{ 
    active->setQuantums(active->getQuantums()+1); 
} 
DBG(("Number of threads in ready list is - %d",(ready.size()))) 

blockTimerSignal(UNBLOCK); 
} 

При выполнении siglongjmp(*active->getEnv(),1);

Это происходит только для основной thread (Первый поток программы с id 0). это также происходит после того, как программа запускается некоторое время, что означает, что в середине программы он может выполнять siglongjmp для активного потока, но когда он пытается снова через какое-то время, он дает ошибку.

Добавление мой прекращает функцию, если помогает:

int uthread_terminate(int tid) { 
    DBG(("Terminate - %d", tid)) 

    if (tid == 0){ 
     // delete all (threads) - don't think it's needed because using stl! 
     // TODO : check if needed - and then delete all lists ! 
     //Added by Roni - Deleting all lists! 
     while(!sleeping.empty()){ 
      delete (sleeping.front()); 
      sleeping.pop_front(); 
     } 

     while(!suspended.empty()){ 
      delete (suspended.front()); 
      suspended.pop_front(); 
     } 

     while(!ready.empty()){ 
      delete (ready.front()); 
      ready.pop_front(); 
     } 


     exit(0); 
    } 

    pThread t = getThread(tid); 
    if (t == NULL){ 
     errmsgLibrary(THREAD_NOT_FOUND); 
     return FAIL; 
    } 
    Thread::threadState state = t->getState(); 
    DBG(("Terminate - %d in State %d", tid, state)) 
    DBG(("Number of threads in ready list is - %d",(ready.size()))) 
    blockTimerSignal(BLOCK); 
    switch (state){ 
    case (Thread::RUNNING): 
     //DBG(("Running Case")) 
     //DBG(("Active thread id is: %d ",active->getTid())) 
      delete active; 
      active = NULL; 
    //DBG(("Finsihed running Case")) 
      scheduler(); 

      break; 
    case (Thread::READY): 
     //DBG(("ready Case")) 
      ready.remove(t); 
      delete t; 
      //DBG(("Finsihed ready Case")) 
     break; 
    case (Thread::SLEEP): 
      sleeping.remove(t); 
      delete t; 
     break; 
    case (Thread::SUSPENDED): 
      suspended.remove(t); 
      delete t; 
      break; 
    default: 
     break; 
    } 
    //DBG(("Number of threads in ready list is - %d",(ready.size()))) 
    blockTimerSignal(UNBLOCK); 
    return SUCCESS; 
} 

Answer 1

В догадка, Вы используете siglongjmp здесь, и, вероятно, не меняя стеки между вызовами.

Рассмотрите возможность использования getcontext(), swapcontext() и makecontext().