以非确定方式使用pthread时的分段错误

Question

问题是，当我在单个核心上运行下面的代码时，有时它运行正常，有时会出现分段错误。在多核机器上可能会出现这个问题的频率更高。我需要知道我的程序中引入了这种非确定性，我该如何解决它。谢谢。

int numThreads = 4; 

class Evaluator; 

struct E { 
    Evaluator* evaluator; 
    int id; 
}; 

class Evaluator { 
public: 
    pthread_t * threads; 
    sem_t* fork_sync; 
    sem_t* join_sync; 
    int tin; 
    pthread_mutex_t tin_mut; 

    double * d; 
    int sz; 
    int cursor; 
    pthread_mutex_t c_mut; 

    Evaluator(sem_t* fs, sem_t* js) { 
     fork_sync = fs; 
     join_sync = js; 
     threads = new pthread_t[numThreads]; 
     tin = 0; 
     pthread_mutex_init(&tin_mut,NULL); 
     for(int i=0 ;i<numThreads; i++) { 
      E arg; 
      arg.evaluator = this; 
      arg.id = i; 
      pthread_create(&threads[i],NULL,(void* (*) (void*))func,(void*)&arg); 
     } 


     //dummy init 
     sz = 20; 
     d = new double[sz]; 
     for(int i=0; i<sz ; i++) d[i] = .5 + i; 
     cursor = 0; 
     pthread_mutex_init(&c_mut,NULL); 
    } 

    static void func(E* e) {   
     Evaluator* eval = e -> evaluator; 
     eval -> go(e -> id); 
    } 

    void reset() { 
     cursor = 0; 
    } 

    void go(int id) { 
     while(1) { 
      sem_wait(fork_sync); 

      pthread_mutex_lock(&tin_mut); 
      ++tin; 
      pthread_mutex_unlock(&tin_mut); 

      while(1) { 
       int idx; 
       pthread_mutex_lock(&c_mut); 
       idx = cursor++; 
       pthread_mutex_unlock(&c_mut); 
       if(idx >= sz) break; 
       // do the evaluation 
       cout << "evaluating index " << idx << " using thread " << id << endl; 
      } 

      int remain; 
      pthread_mutex_lock(&tin_mut); 
      remain = --tin; 
      pthread_mutex_unlock(&tin_mut); 
      if(remain == 0) sem_post(join_sync); 
     } 
    } 


}; 

int main(int argc, char *argv[]) { 

    sem_t fork_sync; 
    sem_t join_sync; 

    sem_init(&fork_sync,0,0); 
    sem_init(&join_sync,0,0); 

    Evaluator e(&fork_sync,&join_sync); 


    //evaluating t times 
    int t = 3; 
    for(int i=0; i<t; i++) { 
     cout << "---------- evaluation number :" << i << endl; 
     e.reset(); 
     for(int j=0; j<numThreads; j++) sem_post(&fork_sync); 
     sem_wait(&join_sync); 
     cout << endl; 
    } 

    return 0; 
} 

Answer 1

这里是一个快速解决第二个错误。这确保工作线程在启动另一个迭代之前完成。

--- a/misc/so/sem_wait/q.cpp 
+++ b/misc/so/sem_wait/q.cpp 
@@ -83,7 +83,7 @@ public: 
      pthread_mutex_lock(&tin_mut); 
      remain = --tin; 
      pthread_mutex_unlock(&tin_mut); 
-   if(remain == 0) sem_post(join_sync); 
+   sem_post(join_sync); 
     } 
    } 

@@ -107,9 +107,11 @@ int main(int argc, char *argv[]) { 
     cout << "---------- evaluation number :" << i << endl; 
     e.reset(); 
     for(int j=0; j<numThreads; j++) sem_post(&fork_sync); 
-  sem_wait(&join_sync); 
+  for(int j=0; j<numThreads; j++) sem_wait(&join_sync); 
     cout << endl; 
    } 

+ cout << "exit" << endl; 
+ 
    return 0; 
} 

Answer 2

您能否在debugger中重现问题？

如果您编译了优化的代码;尽管问题很可能出现在您的代码中，但可能值得尝试关闭编译器优化（-O0）

Answer 3

Navid，请您提供一个下次可用的示例吗？

它不会伤害那么多添加上你的例子

#include <pthread.h> 
#include <semaphore.h> 
#include <iostream> 

using namespace std; 

// compile with: g++ -g -pthread main.cpp -o main -lrt -lpthread 

顶部以下行当我在调试器中启动该程序，然后确实崩溃有时在sem_wait（）线（有时它不会崩溃！）

void go(int id) { 
    while(1) { 
     sem_wait(fork_sync); // <--- seems to crash here 
     ... 

Answer 4

arg在堆栈上。您正在使用其地址并将此地址传递给另一个线程。竞争条件（堆栈中的值可以在新创建的线程读取之前被覆盖）。

E arg; 
arg.evaluator = this; 
arg.id = i; 
pthread_create(&threads[i],NULL,(void* (*) (void*))func,(void*)&arg); 

解决方案：

E* arg = new E(); 
arg->evaluator = this; 
arg->id = i; 
pthread_create(&threads[i],NULL,(void* (*) (void*))func,(void*)arg); 

而且在func不要忘记delete e。

Answer 5

对象的地址被破坏。这是由于在堆栈上分配args元素引起的。当线程启动时，它可能包含或不包含有效值。
这是支持Vokuhila-Oliba的答案，因为fork_sync是线程第一次尝试访问对象内存。
编辑
的代码对我的作品有以下改动（20次测试没有崩溃）

for(int i=0 ;i<numThreads; i++) { 
          E* arg = new E; 
          arg->evaluator = this; 
          arg->id = i; 
          pthread_create(&threads[i],NULL,func,arg); 
         } 

static void* func(void* e) { 
     Evaluator* eval = reinterpret_cast<E*>(e) -> evaluator; 
     eval -> go(reinterpret_cast<E*>(e) -> id); 
     delete(e); 
     return NULL; 
    }