¿Pthreads y Vfork?

Estoy tratando de verificar qué sucede realmente con los subprocesos mientras uno de ellos ejecuta vfork.
La especificación dice que el "subproceso de control" principal está "suspendido" hasta que el proceso secundario llama a exec* o _exit.
Según tengo entendido, el consenso es que significa que todo el proceso principal (es decir, con todos sus subprocesos) está suspendido.
Me gustaría confirmarlo mediante un experimento.
Hasta ahora realizó varios experimentos, todos los cuales sugieren que se están ejecutando otros pthreads. Como no tengo experiencia con Linux, sospecho que mi interpretación de estos experimentos es incorrecta, y aprender la interpretación real de estos resultados podría ayudar a evitar más conceptos erróneos en mi vida.
Así que aquí están los experimentos que hice:

Experimento I

#include<unistd.h>
#include<signal.h>
#include<errno.h>
#include<cstring>
#include<string>
#include<iostream>
using namespace std;
void * job(void *x){
  int pid=vfork();
  if(-1==pid){
    cerr << "failed to fork: " << strerror(errno) << endl;
    _exit(-3);
  }
  if(!pid){
    cerr << "A" << endl;
    cerr << "B" << endl;
    if(-1 == execlp("/bin/ls","ls","repro.cpp",(char*)NULL)){
      cerr << "failed to exec : " << strerror(errno) << endl;
      _exit(-4);//serious problem, can not proceed
    }
  }
  return NULL;
}
int main(){
  signal(SIGPIPE,SIG_IGN);
  signal(SIGCHLD,SIG_IGN);
  const int thread_count = 4;
  pthread_t thread[thread_count];
  int err;
  for(size_t i=0;i<thread_count;++i){
    if((err = pthread_create(thread+i,NULL,job,NULL))){
      cerr << "failed to create pthread: " << strerror(err) << endl;
      return -7;
    }
  }
  for(size_t i=0;i<thread_count;++i){
    if((err = pthread_join(thread[i],NULL))){
      cerr << "failed to join pthread: " << strerror(err) << endl;
      return -17;
    }
  }
}

Hay 44 pthreads, todos los cuales realizan vfork y exec en el niño.
Cada proceso hijo realiza dos operaciones de salida entre vfork y exec "A" y "B".
La teoría sugiere que la salida debe decir ABABABABABA... sin anidar.
Sin embargo, la salida es un desastre total:por ejemplo:

AAAA



BB
B

B

Experimento II

Sospechando que usar I/O lib después de vfork podría ser una mala idea, reemplacé la función job() con lo siguiente:

const int S = 10000000;
int t[S];
void * job(void *x){
  int pid=vfork();
  if(-1==pid){
    cerr << "failed to fork: " << strerror(errno) << endl;
    _exit(-3);
  }
  if(!pid){
    for(int i=0;i<S;++i){
      t[i]=i;
    }
    for(int i=0;i<S;++i){
      t[i]-=i;
    }
    for(int i=0;i<S;++i){
      if(t[i]){
        cout << "INCONSISTENT STATE OF t[" << i << "] = " << t[i] << " DETECTED" << endl;
      }
    }
    if(-1 == execlp("/bin/ls","ls","repro.cpp",(char*)NULL)){
      cerr << "failed to execlp : " << strerror(errno) << endl;
      _exit(-4);
    }
  }
  return NULL;
}

Esta vez, realizo dos bucles de modo que el segundo deshace los resultados del primero, por lo que al final la tabla global t[] debe volver al estado inicial (que por definición es todo ceros).
Si al ingresar al proceso secundario se congelan los otros pthreads, lo que les impide llamar a vfork hasta que el elemento secundario actual termine los bucles, entonces la matriz debe ser todo ceros en el final.
Y confirmé que cuando uso fork() en lugar de vfork(), entonces el código anterior no produce ningún resultado.
Sin embargo, cuando cambio fork() a vfork() obtengo toneladas de inconsistencias reportadas a stdout.

Experimento III

Un experimento más se describe aquí https://unix.stackexchange.com/a/163761/88901:implicó llamar a dormir, pero en realidad los resultados fueron los mismos cuando lo reemplacé con un largo for bucle.

Respuesta aceptada:

La página del manual de Linux para vork es bastante específico:

#include<unistd.h>
#include<signal.h>
#include<errno.h>
#include<atomic>
#include<cstring>
#include<string>
#include<iostream>

std::atomic<int> start;
std::atomic<int> counter;
const int thread_count = 4;

void *vforker(void *){
  std::cout << "vforker starting\n";
  int pid=vfork();
  if(pid == 0){
    start = 1;
    while (counter < (thread_count-1))
      ;
    execlp("/bin/date","date",nullptr);
  }
  std::cout << "vforker done\n";
  return nullptr;
}

void *job(void *){
  while (start == 0)
    ;
  counter++;
  return NULL;
}

int main(){
  signal(SIGPIPE,SIG_IGN);
  signal(SIGCHLD,SIG_IGN);
  pthread_t thread[thread_count];
  counter = 0;
  start   = 0;

  pthread_create(&(thread[0]), nullptr, vforker, nullptr);
  for(int i=1;i<thread_count;++i)
    pthread_create(&(thread[i]), nullptr, job, nullptr);

  for(int i=0;i<thread_count;++i)
    pthread_join(thread[i], nullptr);
}