Discussion :

[NoIdea]

Bonjour,

Je dispose d'une fonction, nommons la f. Cette fonction, je ne l'ai pas �crite, et je ne veux pas avoir � la modifier.
Le principal souci de cette fonction est son temps d�ex�cution qui peut varier entre 0 secondes et plusieurs jours en fonction de la "chance" (l'algorithme est probabiliste), et des donn�es en entr�e. Je ne sais pas quelles sont les donn�es consid�r�es comme dures (ou plut�t j'ai une vague id�e, mais ce n'est pas suffisant).

Ce que j'aimerais faire, c'est ex�cuter cette fonction dans un thread s�par� et dans le thread principal faire un timer qui termine le thread au bout de 10 minutes par exemple.

Le probl�me : Je ne peux avec std::thread interrompre proprement un thread "sans son accord". Or, je ne peux mettre de "breakpoints", dans la fonction f.
Avez-vous une solution � ce probl�me (ind�pendant de l'OS et qui utilise std::thread si possible) ?

Note : mettre le thread en sleep n'est pas vraiment une solution satisfaisante...

Merci

[imperio]

Simple question comme ca mais si tu fais ceci :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <thread>
#include <iostream>
 
void hello(){
    while (1)
      std::cout << "Hello from thread " << std::endl;
}
 
int main(){
    std::thread *t1 = new std::thread(hello);
    usleep(1000);
    std::cout << "Let's try that !" << std::endl;
    delete t1;
    std::cout << "Is it dead ?" << std::endl;
    usleep(1000);
    return 0;
}

Est-ce que ca stoppe le thread ?

[Iradrille]

Est-ce que ca stoppe le thread ?

Plus ou moins

~thread();
Thread destructor
Destroys the thread object.

If the thread is joinable when destroyed, terminate() is called.

TOUJOURS join ou detach un thread avant de le supprimer.

Si le traitement long contient une boucle, tu peux avoir quelques chose du genre

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void foo(time_t maxTime, int& result) {
    time_t start = time(nullptr);
    time_t now = start;
    result = -1;
    while(/* pas trouvé le résultat && */ now - start < maxTime) {
       // chercher le résultat
       now = time(nullptr);
     }
}
 
int main() {
    int result;
    std::thread t(std::bind(foo, 600 /* 600 sec == 10 min */, std::ref(result)));
    t.join();
    std::cout << result;
    return 0;
}

[NoIdea]

Est-ce que ca stoppe le thread ?

Je n'ai pas test�, mais il me semble que oui. Cependant, cela ne le stoppe pas proprement.

Si le traitement long contient une boucle

Je n'ai pas de contr�le sur la fonction longue.

[Iradrille]

Avec aucun controle sur la fonction � ex�cuter c'est pas facile.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
#include <thread>
#include <chrono>
 
void foo() { while(1); }
 
int main() {
	std::thread(foo).detach();
	std::this_thread::sleep_for(std::chrono::seconds(5));
	return 0;
}

Tu peux le detach, il sera termin� en m�me temps que le thread principal, mais tu perd tout contr�le dessus.

[NoIdea]

Tu peux le detach, il sera termin� en m�me temps que le thread principal, mais tu perd tout contr�le dessus.

Le souci, c'est que l'id�e est de relancer l'algorithme : l'algorithme �tant probabiliste, il se peut qu'on ait plus de chance.
L'algorithme prend beaucoup de m�moire (300-400 Mo), on ne peut donc le mettre en sleep/le terminer de mani�re non propre.

[Iradrille]

Y a t'il une r�elle diff�rence entre le relancer, et le laisser s'ex�cuter ? Il y a plus de chance de trouver une solution en le lan�ant 2 fois 10 minutes plut�t qu'une fois 20 minutes ?

Peut �tre que la solution est de lancer le calcul dans un autre process ?

[NoIdea]

Y a t'il une r�elle diff�rence entre le relancer, et le laisser s'ex�cuter ? Il y a plus de chance de trouver une solution en le lan�ant 2 fois 10 minutes plut�t qu'une fois 20 minutes ?

Je pense, �a fait partie des choses que je veux v�rifier.

Peut �tre que la solution est de lancer le calcul dans un autre process ?

C'est la solution qui parait le plus facile. Cependant, je trouve cela �trange et quelque peu g�nant (les threads sont beaucoup plus l�gers..., plus facile � manipuler, pas de pipe pour transf�rer les donn�es, std::process n'existe pas encore...).

Je souhaitais v�rifier qu'il n'y avait pas de solution avec des threads. Si tel est le cas, comme vous semblez le dire, je me tournerai vers les processus.