Frage zu pthread_testcancel();

[HaWe]

neinnein, jede die es betrifft, wird nur 1x von 1 Thread aus angesprungen.
Ich habe mal eine kleine Simulation geschrieben:

Einer der Threads startet eine Fibonacci-Berechnung linear (sehr schnell),
der andere eine andere, rekursive Fibinacci-Funktion (viel langsamer).

lässt man jetzt die Fibonacci (93) berechnen, ist Thread2-linear schnell fertig (nur zu Simulationszwecken),
Thread1-rekursiv braucht aber ewig.

beide Threads können durch einen 3. Thread abgebrochen werden, wenn man ESC drückt (um Thread2-linear zu erwischen, irre schnell ... ).

Aber egal, ob jetzt in Fibo-Rekursiv ein pthread_testcancel drin steht oder nicht:
es dauert immer gleich lang bis zum Abbruch des rekursiven , nämlich (bei meinem Linux) ca. 3 sec.

Eigentlich ist das zu lang, und es müsste auch viel schneller gehen, da sich jede Sekunde mindestens 100x die Funktion selber rekursiv aufruft, und daher theoretisch also auch innerhalb von 10ms abgebrochen werden müsste mit pthread_testcancel() am Anfang eines jeden neuen (rekursiven) Funktionsstarts
- fast ewig lang allein bis zur Reaktion auf den Abbruch, vergleicht man es mit dem kompletten Durchlauf der gesamten kompletten linearen Funktion bis zur 200. Iteration, erkennbar auch an der ausgegeben printf-ESC-Sequenz im Terminal bis zur letztendlichen Abbruch-Reaktion.

Sehr effektiv, gelinde gesagt, scheint also pthread_testcancel in der "abhängigen" rekursiven Funktion nicht zu wirken...

/*
 *  Fibonacci numbers
 *  simulaneous competition:
 *  linear vs. recursive calculation
 * 
 */


#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <termio.h>

#define msleep(ms)  usleep(1000*ms)

pthread_t threadID0, threadID1, threadID2;

long f;

volatile int running1 = 1;
volatile int running2 = 1;


// ********************************************************************


bool kbhit(void)
{
    struct termios original;
    tcgetattr(STDIN_FILENO, &original);

    struct termios term;
    memcpy(&term, &original, sizeof(term));
    term.c_lflag &= ~ICANON;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);

    int characters_buffered = 0;
    ioctl(STDIN_FILENO, FIONREAD, &characters_buffered);
    tcsetattr(STDIN_FILENO, TCSANOW, &original);

    bool pressed = (characters_buffered != 0);

    return pressed;
}

// ********************************************************************


inline unsigned long long fibolinear( long n ) {
  volatile static unsigned long long  fibarr[3]; 
  static long i;

  fibarr[0]=0;
  fibarr[1]=1;
  fibarr[2]=0;

  if(n==0) return 0;

  for (i=1; i <= n; i++) {
     
      fibarr[0]=fibarr[1];
      fibarr[1]=fibarr[2];
      fibarr[2]=fibarr[1]+fibarr[0];
      printf("\n order linear: %ld  %llu \n" , i, fibarr[2]);       
  }
  return fibarr[2];
 
}



inline unsigned long long fiborecurs( long n ) {
  unsigned long long   llbuf;  
  volatile static long order = 0;

  pthread_testcancel(); // <<<<<<<<<<<<<<<<<<<< oder mal weglassen!

  if ( n==0 )    { llbuf = 0;  }
  else   
  if ( n==1 )    { llbuf = 1;  }
  else {
    
     llbuf = fiborecurs(n-1) + fiborecurs(n-2);         
     if(n > order) {
         order = n;
         printf("\n order recursive: %ld  %llu \n" , order, llbuf); 
     }     
  }
  return (llbuf); 
}



// ********************************************************************




void* threadf2(void *) {
    unsigned long long res;
    int RETVAL = 0;
       
    res = fibolinear(f);
    
    printf("\n\nFibonacci (%ld) (linear) is = %llu \n", f, res);     
    printf("===============================================\n\n"); 

    running2 = 0;
    msleep(100);
    
    return (void*)RETVAL; ;
    
}



void* threadf1(void *) {
    unsigned long long res;
    int RETVAL = 0;
 
    res = fiborecurs(f);
    
    printf("\n\nFibonacci (%ld) (recursive) is = %llu \n", f, res); 
    printf("===============================================\n\n");    
    
    running1 = 0;
    msleep(100);
    
    return (void*)RETVAL; ;
    
}




void* threadW0(void *) {
    int RETVAL = 0;
    
    while(running1 || running2) {
 
      if (kbhit())
      {
         int ch = getchar();
         if(ch==27) {       
            // DEBUG    
            printf("\nin pthread0: user kbd press ESC...  ");  
            printf("\npthread0 cancelling pthread 1... ");                         
            if(threadID1) pthread_cancel(threadID1);
            
            // DEBUG 
            printf("\npthread0 cancelling pthread 2...");             
            if(threadID2) pthread_cancel(threadID2);
            
            running1 = 0;
            running2 = 0; 
            
            // DEBUG 
            printf("\nin pthread0: program interrupted by user  \n");
            
            RETVAL = 27;  // user break  
            return (void*)RETVAL; 
         }   
      }   
      msleep(1000);
      printf(".");
      fflush(stdout);
    }
    return (void*)RETVAL; 
    
}

// ********************************************************************


int main() {	   
    void *retval0 = NULL, *retval1 = NULL, *retval2 = NULL;
    
    printf("enter Fibonacci order: ");
    scanf("%ld", &f);      
    
    pthread_create( &threadID1, 0, threadf1, 0 ); 
    pthread_create( &threadID2, 0, threadf2, 0 ); 
    pthread_create( &threadID0, 0, threadW0, 0 ); 
    
         
    pthread_join( threadID0,  &retval0 );
    pthread_join( threadID1,  &retval1 );    
    pthread_join( threadID2,  &retval2 );
    
    // DEBUG
    printf("\nretval0 = %d \n", (int)retval0);
    printf("\nretval1 = %d \n", (int)retval1);
    printf("\nretval2 = %d \n", (int)retval2);
    printf("\nprogram finished \n");

    return 0;
    
}