Malloc 分段错误

这是发生分段错误的代码段（未调用 perror）：

job = malloc(sizeof(task_t));
if(job == NULL)
    perror("malloc");

更准确地说，gdb 说segfault发生在一个__int_malloccall，这是一个子例程调用malloc.

由于 malloc 函数是与其他线程并行调用的，最初我认为这可能是问题所在。 我使用的是 glibc 2.19 版本。

数据结构：

typedef struct rv_thread thread_wrapper_t;

typedef struct future
{
  pthread_cond_t wait;
  pthread_mutex_t mutex;
  long completed;
} future_t;

typedef struct task
{
  future_t * f;
  void * data;
  void *
  (*fun)(thread_wrapper_t *, void *);
} task_t;

typedef struct
{
  queue_t * queue;
} pool_worker_t;

typedef struct
{
  task_t * t;
} sfuture_t;

struct rv_thread
{
  pool_worker_t * pool;
};

现在未来的实施：

future_t *
create_future()
{
  future_t * new_f = malloc(sizeof(future_t));
  if(new_f == NULL)
    perror("malloc");
  new_f->completed = 0;
  pthread_mutex_init(&(new_f->mutex), NULL);
  pthread_cond_init(&(new_f->wait), NULL);
  return new_f;
}

int
wait_future(future_t * f)
{
  pthread_mutex_lock(&(f->mutex));
  while (!f->completed)
    {
      pthread_cond_wait(&(f->wait),&(f->mutex));
    }
  pthread_mutex_unlock(&(f->mutex));
  return 0;
}

void
complete(future_t * f)
{
  pthread_mutex_lock(&(f->mutex));
  f->completed = 1;
  pthread_mutex_unlock(&(f->mutex));
  pthread_cond_broadcast(&(f->wait));
}

线程池本身：

pool_worker_t *
create_work_pool(int threads)
{
  pool_worker_t * new_p = malloc(sizeof(pool_worker_t));
  if(new_p == NULL)
    perror("malloc");
  threads = 1;
  new_p->queue = create_queue();
  int i;
  for (i = 0; i < threads; i++){
    thread_wrapper_t * w = malloc(sizeof(thread_wrapper_t));
    if(w == NULL)
      perror("malloc");
    w->pool = new_p;
    pthread_t n;
    pthread_create(&n, NULL, work, w);
  }
  return new_p;
}

task_t *
try_get_new_task(thread_wrapper_t * thr)
{
  task_t * t = NULL;
  try_dequeue(thr->pool->queue, t);
  return t;
}

void
submit_job(pool_worker_t * p, task_t * t)
{
  enqueue(p->queue, t);
}

void *
work(void * data)
{
  thread_wrapper_t * thr = (thread_wrapper_t *) data;
  while (1){
    task_t * t = NULL;
    while ((t = (task_t *) try_get_new_task(thr)) == NULL);
    future_t * f = t->f;
    (*(t->fun))(thr,t->data);
    complete(f);
  }
  pthread_exit(NULL);
}

最后是task.c：

pool_worker_t *
create_tpool()
{
  return (create_work_pool(8));
}

sfuture_t *
async(pool_worker_t * p, thread_wrapper_t * thr, void *
(*fun)(thread_wrapper_t *, void *), void * data)
{
  task_t * job = NULL;
  job = malloc(sizeof(task_t));
  if(job == NULL)
    perror("malloc");
  job->data = data;
  job->fun = fun;
  job->f = create_future();
  submit_job(p, job);
  sfuture_t * new_t = malloc(sizeof(sfuture_t));
  if(new_t == NULL)
    perror("malloc");
  new_t->t = job;
  return (new_t);
}

void
mywait(thread_wrapper_t * thr, sfuture_t * sf)
{
  if (sf == NULL)
    return;
  if (thr != NULL)
    {
      while (!sf->t->f->completed)
        {
          task_t * t_n = try_get_new_task(thr);
          if (t_n != NULL)
            {
          future_t * f = t_n->f;
          (*(t_n->fun))(thr,t_n->data);
          complete(f);
            }
        }
      return;
    }
  wait_future(sf->t->f);
  return ;
}

该队列是lfds无锁队列。

#define enqueue(q,t) {                                 \
    if(!lfds611_queue_enqueue(q->lq, t))             \
      {                                               \
        lfds611_queue_guaranteed_enqueue(q->lq, t);  \
      }                                               \
  }

#define try_dequeue(q,t) {                            \
    lfds611_queue_dequeue(q->lq, &t);               \
  }

每当对 async 的调用次数非常多时，就会出现此问题。

Valgrind 输出：

Process terminating with default action of signal 11 (SIGSEGV)
==12022==  Bad permissions for mapped region at address 0x5AF9FF8
==12022==    at 0x4C28737: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)

我已经弄清楚问题是什么：堆栈溢出。

首先，让我解释一下为什么 malloc 内部会发生堆栈溢出（这可能就是您阅读本文的原因）。当我的程序运行时，每次开始（递归）执行另一个任务时，堆栈大小都会不断增加（因为我对其进行编程的方式）。但每次这样，我都必须使用 malloc 分配一个新任务。然而，malloc 会进行其他子例程调用，这使得堆栈的大小增加甚至比执行另一个任务的简单调用还要多。所以，发生的情况是，即使没有 malloc，我也会遇到堆栈溢出。然而，因为我有 malloc，所以堆栈溢出的那一刻是在 malloc 中，在通过进行另一个递归调用而溢出之前。 下图显示了发生的情况：

初始堆栈状态：

-------------------------
| recursive call n - 3  |
-------------------------
| recursive call n - 2  |
-------------------------
| recursive call n - 1  |
-------------------------
|        garbage        |
-------------------------
|        garbage        | <- If the stack passes this point, the stack overflows.
-------------------------

malloc 调用期间的堆栈：

-------------------------
| recursive call n - 3  |
-------------------------
| recursive call n - 2  |
-------------------------
| recursive call n - 1  |
-------------------------
|        malloc         |
-------------------------
|     __int_malloc      | <- If the stack passes this point, the stack overflows.
-------------------------

然后堆栈再次缩小，我的代码进入了新的递归调用：

-------------------------
| recursive call n - 3  |
-------------------------
| recursive call n - 2  |
-------------------------
| recursive call n - 1  |
-------------------------
| recursive call n      |
-------------------------
|        garbage        | <- If the stack passes this point, the stack overflows.
-------------------------

然后，它在这个新的递归调用中再次调用 malloc。然而，这一次它溢出了：

-------------------------
| recursive call n - 3  |
-------------------------
| recursive call n - 2  |
-------------------------
| recursive call n - 1  |
-------------------------
| recursive call n      |
-------------------------
|        malloc         | <- If the stack passes this point, the stack overflows.
-------------------------
|     __int_malloc      | <- This is when the stack overflow occurs.
-------------------------

[答案的其余部分更集中于为什么我的代码中特别出现这个问题。]

通常，当递归计算斐波那契数时，例如，计算某个数字 n 时，堆栈大小随该数字线性增长。 但是，在本例中，我正在创建任务，使用队列来存储它们，并将（fib）任务出队以供执行。如果你把它画在纸上，你会发现任务的数量随着 n 呈指数增长，而不是线性增长（另请注意，如果我在创建任务时使用堆栈来存储任务，则分配的任务数量为以及堆栈大小只会随着 n 线性增长。所以会发生的是堆栈随着 n 呈指数增长，导致堆栈溢出...现在是为什么这种溢出发生在对 malloc 的调用中的部分。所以基本上，我上面解释过，堆栈溢出发生在 malloc 调用内部，因为它是堆栈最大的地方。所发生的情况是堆栈几乎爆炸，并且由于 malloc 调用其中的函数，堆栈的增长不仅仅是 mywait 和谎言。

谢谢你们！如果不是你的帮助我根本无法弄清楚！