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.