C/C++ - Timer

Ciao a tutti,

Sto svolgendo un esercizio con i thread in cui mi viene richiesto di inserire da tastiera due parametri:
- Accuratezza
- Tempo massimo di attesa dopo cui i thread verranno chiusi.

L'algoritmo riguarda la serie per il calcolo di PI greco di Gregory Leibniz, ho risolto questa parte.

Però non riesco a capire come implementare il tempo, dovrei avere un tempo iniziale in cui faccio partire

i Thread a cui vado a sommare appunto l'attesa inserita dall'utente e nel momento in cui l'orario arriva

a (Attesa + T iniziale) esco......

C'è qualcuno che può darmi un suggerimento???

Per la gestione del tempo, c' è la libreria time.h (cplusplus.com/reference/ctime/)

Non riesci a farmi un esempio pratico al fine di poter capire il funzionamento? Sono alle prime armi.....

Alcuni esempi sono già nel sito. Cosa non riesci a capire?
(Posta il codice del tuo tentativo)

io risolverei il tutto così

time_t oraAtt = time(NULL);
int t_max; //tempo espresso in secondi
i = 0;
for (i=0; i<10.000; i++)
{
time_t oraAtt2 = time (NULL);
if (double difftime(time_t oraAtt, time_t oraAtt2) == t_max)
{
break;
}
}

Il ciclo non funziona perché hai invertito gli argomenti passati alla finzione difftime (cplusplus.com/reference/ctime/difftime/).

La funzione difftime restituisce un valore double, quindi non è consigliabile utilizzare l' uguaglianza stretta nella condizione if, ma il maggiore_uguale.

Ti posto tutto il codice dell'esercizio - si compila, esegue i calcoli ma non rispetta il tempo!!!!

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <math.h>

void *thread_function(void *arg)
{
    float pi_greco = 0;
    float pi_grecotot = 0;
    float error;
    int i = 0;
    int denominatore = 1;
    float accuracy;
    printf("Inserisci il grado di accuratezza : ");
    scanf("%f", &accuracy);
    do {
        if (i%2 == 0) {
            pi_greco = (float)4 / (float) denominatore;
            denominatore = denominatore + 2;
        }
        else{
            pi_greco = -(float)4 / (float)denominatore;
            denominatore = denominatore + 2;
        }
        pi_grecotot = pi_grecotot + pi_greco;
        i++;
        error = pi_grecotot - M_PI;
    } while (fabs(error) > accuracy);
    printf("Il valore di pigreco approssimato a %f è %f\n", accuracy, pi_grecotot);
    
}

void *thread_check_time(void *arg)
{
    pthread_t thread_leibniz;
    time_t oraAtt, oraAtt2;
    int t_max;
    double dif_sec;
    printf("Inserisci il tempo massimo di attesa(espresso in secondi): ");
    scanf("%d", &t_max);
    if (t_max ==0)
    {
        printf("Inserisci un intervallo di tempo superiore a 0");
    }
    time(&oraAtt);
    pthread_create(&thread_leibniz, NULL, thread_function, NULL);
    while (dif_sec == t_max) {
        time(&oraAtt2);
        dif_sec = difftime(oraAtt2, oraAtt);
    }
    pthread_join(thread_leibniz,NULL);
    
}


int main(void)
{
    pthread_t thread_time;
    pthread_create(&thread_time, NULL, thread_check_time, NULL);
    pthread_join(thread_time,NULL);
}

il testo dell'esercizio è questo invece:
Scrivere un programma che attiva una serie di thread per effettuare il calcolo approssimato di &#960;.

Il programma principale prende come input da riga di comando un parametro che indica il grado di accuratezza (accuracy) per il calcolo di &#960; e il tempo massimo di attesa dopo cui il main interrompe tutti i thread.

I thread vengono utilizzati (cercando di massimizzare il numero di operazioni effettuate nel lasso di tempo a disposizione) per effettuare le seguenti operazioni per il calcolo di &#960; tramite la serie di Gregory-Leibniz: &#960; = 4/1 &#8722; 4/3 + 4/5 &#8722; 4/7 + 4/9 &#8722; 4/11 ...

I thread vengono tutti interrotti quando una delle due condizioni seguenti risulta verificata:&#8232;    
1) il tempo massimo di attesa è stato superato;&#8232;    
2) la differenza tra il valore stimato di &#960; e il valore Math.PI è minore di accuracy.

Questo è il nuovo codice modificato:

#include <stdio.h>
#include <pthread.h>
#include <time.h>
#include <math.h>
#include <unistd.h>

time_t oraAtt;

void *thread_function(void *arg)
{
    float pi_greco = 0;
    float pi_grecotot = 0;
    float error;
    int i = 0;
    int denominatore = 1;
    float accuracy;
    accuracy =*(float*)arg;
    do {
        if (i%2 == 0) {
            pi_greco = (float)4 / (float) denominatore;
            denominatore = denominatore + 2;
        }
        else{
            pi_greco = -(float)4 / (float)denominatore;
            denominatore = denominatore + 2;
        }
        pi_grecotot = pi_grecotot + pi_greco;
        i++;
        error = pi_grecotot - M_PI;
    } while (fabs(error) > accuracy);
    printf("Il valore di pigreco approssimato a %f è %f\n", accuracy, pi_grecotot);
    return NULL;
    
}

void *thread_check_time(void *arg)
{
    time_t oraAtt2;
    double dif_sec;
    int t_max;
    t_max = *(int*)arg;
    if (t_max == 0)
    {
        printf("Impossibile procedere tempo inserito uguale a 0");
    }
    //time(&oraAtt);
    while (dif_sec <= t_max) {
        time(&oraAtt2);
        dif_sec = difftime(oraAtt2, oraAtt);
    }
    //0pthread_join(thread_leibniz,NULL);
    return NULL;
    
}


int main(void)
{
    int t_max;
    int i;
    float accuracy;
    time(&oraAtt);
    printf("inserisci il tempo massimo di attesa(espresso in secondi): ");
    scanf("%d", &t_max);
    printf("inserisci il grado di accuratezza");
    scanf("%f", &accuracy);
    pthread_t thread_time;
    pthread_t thread_leibniz;
    pthread_create(&thread_time, NULL, thread_check_time, &t_max);
    for (i=0; i<4; i++){
        pthread_create(&thread_leibniz, NULL, thread_function, &accuracy);   
    }
}

Però c'è qualcosa che non torna.....