Bug#1099624: libc6 2.41 pthread cause pari to FTBFS

[Bill Allombert]

On Mon, Mar 10, 2025 at 12:24:43PM +0100, Bill Allombert wrote:
> On Fri, Mar 07, 2025 at 11:45:10AM +0100, Bill Allombert wrote:
> > I am still unsure wether there is a race condition in PARI or not, however 
> > if
> > there is, it is clear that 2.41 makes the issue much worse.
> 
> Hello Aurélien,
> 
> I have made some progress. I have made a test program that does not use 
> PARI/GP.
> You need to compile with -O0 to hit the race condition.
> 
> gcc  pthread1.c -Wall -O0 -g -pthread -o pthread1

I join a simplified version.

gcc  pthread3.c -Wall -O0 -g -pthread -o pthread3

for i in `seq 1 100`; do echo -n "$i " && sid ./pthread3 || break; done

This crashes or hangs with 2.41 while it works fine with 2.36.

Please tell me if you would like me to do more experiments.

Cheers,
Bill.

/* Copyright (C) 2013  The PARI group.

This file is part of the PARI/GP package.

PARI/GP is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version. It is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY WHATSOEVER.

Check the License for details. You should have received a copy of it, along
with the package; see the file 'COPYING'. If not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

struct mt_state
{
  long workid;
};

struct pari_thread
{
  void * data;
};

struct pari_mt
{
  struct mt_state mt;
};

struct mt_queue
{
  long output;
  long workid;
  pthread_cond_t cond;
  pthread_mutex_t mut;
  pthread_cond_t *pcond;
  pthread_mutex_t *pmut;
};


struct mt_pstate
{
  pthread_t *th;
  struct pari_thread *pth;
  struct mt_queue *mq;
  long n;
  pthread_cond_t pcond;
  pthread_mutex_t pmut;
};

static struct mt_pstate *pari_mt;

#define LOCK(x) pthread_mutex_lock(x); do
#define UNLOCK(x) while(0); pthread_mutex_unlock(x)

void *
pari_thread_start(struct pari_thread *t)
{
  return t->data;
}

static void pari_mt_init(void)
{
  pari_mt = NULL;
}

static void
mt_queue_cleanup(void *arg)
{
  (void) arg;
}

static void*
mt_queue_run(void *arg)
{
  void *args = pari_thread_start((struct pari_thread*) arg);
  struct mt_queue *mq = (struct mt_queue *) args;
  pthread_cleanup_push(mt_queue_cleanup,NULL);
  for(;;)
  {
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
    for(long u=1; u<10000; u++);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
    LOCK(mq->pmut)
    {
      mq->output = -1;
      pthread_cond_signal(mq->pcond);
    } UNLOCK(mq->pmut);
  }
  pthread_cleanup_pop(1);
  return NULL;
}

static long
mtpthread_queue_get(long last, long *workid)
{
  struct mt_pstate *mt = pari_mt;
  struct mt_queue *mq;
  long done = 0;
  mq = mt->mq+last;
  done = mq->output;
  mq->output = 0;
  if (workid) *workid = mq->workid;
  return done;
}

void
mt_queue_reset(void)
{
  struct mt_pstate *mt = pari_mt;
  long i;
  for (i=0; i<mt->n; i++)
    pthread_cancel(mt->th[i]);
  for (i=0; i<mt->n; i++)
    pthread_join(mt->th[i],NULL);
  pari_mt = NULL;
  for (i=0;i<mt->n;i++)
  {
    struct mt_queue *mq = mt->mq+i;
    pthread_cond_destroy(&mq->cond);
    pthread_mutex_destroy(&mq->mut);
  }
  free(mt->mq);
  free(mt->pth);
  free(mt->th);
  free(mt);
}

void
mt_queue_start_lim(struct pari_mt *pt, long lim)
{
  struct mt_pstate *mt =
         (struct mt_pstate*) malloc(sizeof(struct mt_pstate));
  long i;
  mt->mq  = (struct mt_queue *) malloc(sizeof(*mt->mq)*lim);
  mt->th  = (pthread_t *) malloc(sizeof(*mt->th)*lim);
  mt->pth = (struct pari_thread *) malloc(sizeof(*mt->pth)*lim);
  mt->n = lim;
  pthread_cond_init(&mt->pcond,NULL);
  pthread_mutex_init(&mt->pmut,NULL);
  for (i=0;i<lim;i++)
  {
    struct mt_queue *mq = mt->mq+i;
    mq->output = 0;
    mq->pcond  = &mt->pcond;
    mq->pmut   = &mt->pmut;
    pthread_cond_init(&mq->cond,NULL);
    pthread_mutex_init(&mq->mut,NULL);
    mt->pth[i].data = (void*)mq;
  }
  for (i=0;i<lim;i++)
    pthread_create(&mt->th[i],NULL, &mt_queue_run, (void*)&mt->pth[i]);
  pari_mt = mt;
}

int
main(void)
{
  struct pari_mt pt;
  long i, k, workid = 0;
  pari_mt_init();
  for (k = 1; k<1000; k++)
  {
    long lim = 8;
    mt_queue_start_lim(&pt, lim);
    for (i = 0; i < lim; i++)
      mtpthread_queue_get(i, &workid);
    mt_queue_reset();
  }
  printf("Done!\n");
}