[C] Controllo esecuzione con tempo

[kwb]

Ciao a tutti.
Sto facendo un programma dove, preso in input un tempo ( in secondi ) questo esegue il programma finchè o non è scaduto il tempo o le operazioni sono terminate.
Detto questo, il programma esegue delle modifiche su una matrice ed è tutto automatizzato, è quindi chiaro che qualunque tempo inserito sarà certamente maggiore di quello impiegato dal programma a completare le operazioni ( ci mette, a stima, meno di un secondo ).
Il mio problema è che non so come 'slegare' le funzioni che operano sulla matrice dal tempo.
Fino ad ora, quello che sono riuscito a fare è far eseguire un'operazione al secondo, ma non è quello che voglio...
Detto questo, non ho la più pallida idea di come operare per slegare le due cose, anche perchè inizio a sospettare che non sia possibile. Inoltre, non avendo mai avuto a che fare con le librerie del tempo, non so nemmeno dove andare a mettere bene le mani, immagino comunque si debba usare la funzione clock().

EDIT: Aggiungo che ho la necessità che il codice scritto, le librerie utilizzate e quant'altro, siano indipendenti dal sistema.

[:.Blizzard.:]

Una curiosità, ma il discorso del tempo ha un suo perché oppure ti serve a te per valutare l'efficienza del programma?

Cmq non mi è molto chiaro quello che devi fare :D

[Supdario]

Hai 2 modi per farlo, uno è abbastanza semplice ma potrebbe rallentarti il programma, invece l'altro è migliore ma richiede l'uso dei thread.

1) Metti un controllo all'interno dell'algoritmo, che controlla ad ogni esecuzione del ciclo (o quel che è) il tempo, e se è cambiato, esce.
2) Usi un thread per il tuo algoritmo e metti un'attesa nel thread principale. Dopo quell'attesa metti un'istruzione per killare il thread secondario ed ecco fatto.

[kwb]

Una curiosità, ma il discorso del tempo ha un suo perché oppure ti serve a te per valutare l'efficienza del programma?

Cmq non mi è molto chiaro quello che devi fare :D
Ti spiego... Il lavoro che ci è stato dato da fare richiede che vengano effettuate delle operazioni varie ( non mi sto a dilungare su cosa c'è da fare perchè non serve ) su una matrice.
Tuttavia questo può essere fatto in due modi: o è l'utente a dire cosa fare tramite input diretto delle coordinate di una cella della matrice, oppure deve pensarci il programma ( e quindi si deve ideare un algoritmo in base di scegliere quale operazione eseguire e come ).
Siccome non diventava agevole dare delle specifiche troppo diverse a chi sceglieva di operare tramite input sulla matrice e chi sceglieva di fare un algoritmo che operasse, ad entrambi è stato imposto che il programma termini dopo x secondi oppure se non si possono più eseguire operazioni sulla matrice.
È chiaro che se è l'algoritmo a operare direttamente, ci va meno di 1 secondo per concludere le operazioni, quindi l'aggiunta del tempo è superflua...
Ho fatto notare al professore questa particolarità e mi ha detto che voleva comunque eseguissimo l'implementazione del controllo del tempo in ogni caso.

In conclusione, effettivamente per come ho strutturato io ( e molti altri ) il programma, non ha un suo senso l'aggiunta del tempo, però queste sono le richieste :D


Hai 2 modi per farlo, uno è abbastanza semplice ma potrebbe rallentarti il programma, invece l'altro è migliore ma richiede l'uso dei thread.

1) Metti un controllo all'interno dell'algoritmo, che controlla ad ogni esecuzione del ciclo (o quel che è) il tempo, e se è cambiato, esce.
2) Usi un thread per il tuo algoritmo e metti un'attesa nel thread principale. Dopo quell'attesa metti un'istruzione per killare il thread secondario ed ecco fatto.
1. Perchè dovrebbe uscire se il tempo è cambiato?!?
2. Hmm... Sarebbe bello provare, è tanto difficile? Da dove devo partire?

[kwb]

2. Mi stavo giusto chiedendo perchè sui miei manuali non ci fosse menzione dei thread.
Ho appena scoperto che sono sistemi dipendenti, e che i sistemi *nix usano una libreria, quelli windows un'altra ecc...
È vero? Ho letto bene? Se si, non ne posso fare uso... :muro:

[Supdario]

Ah... Non avevo letto quel punto. Effettivamente, salvo alcuni linguaggi interpretati (ad esempio il Java), l'implementazione dei thread è dipendente dalla piattaforma.

A questo punto ti tocca usare la prima opzione, cioè mettere dei controlli in punti strategici all'interno dell'algoritmo.
Il C ti fornisce, all'interno della libreria "time.h", alcune funzioni per la gestione del tempo, tra cui il clock (con cui ottieni la massima precisione).
Piccolo esempio: vuoi avviare un ciclo ed uscire dal ciclo dopo che sono passati 1.5 secondi:


double tempo = 1.5;
clock_t tempo_fine = clock() + tempo*CLOCKS_PER_SEC;
while (clock() < tempo_fine)
{
//Esegui la roba
}

La funzione per ottenere il clock corrente è "clock()". Hai a disposizione anche la costante CLOCKS_PER_SEC, che indica quanti clocks ci sono in un secondo.

[kwb]

Alla fine ho risolto facendo così:
Prendo in input il tempo, lo converto in intero con atoi() poi lo moltiplico per CLOCK_PER_SEC così trovo i clock e poi comparo questo numero con il risultato della funzione clock, se maggiore, fermo tutto! :D