j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads
locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le
master. Et grace a la socket deleguer la tache a l'ordinateur distant
(partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente
(wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michael DOUBEZ
Bruno Causse wrote:
bonjour,
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le master. Et grace a la socket deleguer la tache a l'ordinateur distant (partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente (wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de transparence que tu veux. Typiquement, tu aura d'autres problèmes tels que la localisation, la disponibilité des autres machines, comment les adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même que c'est un pattern qui porte le nom de "Business delegate". Si tu peux avoir un mécanisme de communication asynchrone (type Reactor), tu peux même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les requêtes soit mises dans une queue dont les éléments sont consumés par un thread qui dispatch l'exécution soit dans un thread local soit à une machine distante. Ton abstraction n'est donc plus le thread mais un pipe d'exécution de méthodes. A ces méthodes est associée une "Future", c'est à dire l'instance d'une classe qui gère le retour de données asynchrones (typiquement tu peux demander si le résultat est arrivé ou tu peux l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la distribution de calculs.
-- Michael
Bruno Causse wrote:
bonjour,
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads
locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le
master. Et grace a la socket deleguer la tache a l'ordinateur distant
(partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente
(wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de
transparence que tu veux. Typiquement, tu aura d'autres problèmes tels
que la localisation, la disponibilité des autres machines, comment les
adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même
que c'est un pattern qui porte le nom de "Business delegate". Si tu peux
avoir un mécanisme de communication asynchrone (type Reactor), tu peux
même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les
requêtes soit mises dans une queue dont les éléments sont consumés par
un thread qui dispatch l'exécution soit dans un thread local soit à une
machine distante. Ton abstraction n'est donc plus le thread mais un pipe
d'exécution de méthodes. A ces méthodes est associée une "Future", c'est
à dire l'instance d'une classe qui gère le retour de données asynchrones
(typiquement tu peux demander si le résultat est arrivé ou tu peux
l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la
distribution de calculs.
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le master. Et grace a la socket deleguer la tache a l'ordinateur distant (partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente (wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de transparence que tu veux. Typiquement, tu aura d'autres problèmes tels que la localisation, la disponibilité des autres machines, comment les adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même que c'est un pattern qui porte le nom de "Business delegate". Si tu peux avoir un mécanisme de communication asynchrone (type Reactor), tu peux même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les requêtes soit mises dans une queue dont les éléments sont consumés par un thread qui dispatch l'exécution soit dans un thread local soit à une machine distante. Ton abstraction n'est donc plus le thread mais un pipe d'exécution de méthodes. A ces méthodes est associée une "Future", c'est à dire l'instance d'une classe qui gère le retour de données asynchrones (typiquement tu peux demander si le résultat est arrivé ou tu peux l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la distribution de calculs.
-- Michael
Yann K.
Michael DOUBEZ a écrit :
Bruno Causse wrote:
bonjour,
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le master. Et grace a la socket deleguer la tache a l'ordinateur distant (partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente (wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de transparence que tu veux. Typiquement, tu aura d'autres problèmes tels que la localisation, la disponibilité des autres machines, comment les adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même que c'est un pattern qui porte le nom de "Business delegate". Si tu peux avoir un mécanisme de communication asynchrone (type Reactor), tu peux même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les requêtes soit mises dans une queue dont les éléments sont consumés par un thread qui dispatch l'exécution soit dans un thread local soit à une machine distante. Ton abstraction n'est donc plus le thread mais un pipe d'exécution de méthodes. A ces méthodes est associée une "Future", c'est à dire l'instance d'une classe qui gère le retour de données asynchrones (typiquement tu peux demander si le résultat est arrivé ou tu peux l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la distribution de calculs.
Tu peux aussi voir tout ce qui est MPI pour du traitement distribué.
Michael DOUBEZ a écrit :
Bruno Causse wrote:
bonjour,
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads
locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le
master. Et grace a la socket deleguer la tache a l'ordinateur distant
(partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente
(wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de
transparence que tu veux. Typiquement, tu aura d'autres problèmes tels
que la localisation, la disponibilité des autres machines, comment les
adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même
que c'est un pattern qui porte le nom de "Business delegate". Si tu peux
avoir un mécanisme de communication asynchrone (type Reactor), tu peux
même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les
requêtes soit mises dans une queue dont les éléments sont consumés par
un thread qui dispatch l'exécution soit dans un thread local soit à une
machine distante. Ton abstraction n'est donc plus le thread mais un pipe
d'exécution de méthodes. A ces méthodes est associée une "Future", c'est
à dire l'instance d'une classe qui gère le retour de données asynchrones
(typiquement tu peux demander si le résultat est arrivé ou tu peux
l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la
distribution de calculs.
Tu peux aussi voir tout ce qui est MPI pour du traitement distribué.
j'ai un programme c++ qui est deja parrallelisé (thread locaux)
j'aimerai deleguer des taches (normalement effectuées par des threads locaux) a des ordinateurs distants ("delocalisation sans gros mots").
une sorte de cluster.
voila mon idee:
sur le master:
créer un thread associé a une socket qui serait la partie visible sur le master. Et grace a la socket deleguer la tache a l'ordinateur distant (partie imergées)
Pendant le travail de l'ordinateur distant le thread se met en attente (wait) pour ne pas consommer trop de resources.
etant dans mes "elucubrations", pensez vous que cela tiennent la route.
Ça dépends de la complexité de ton architecture et du degré de transparence que tu veux. Typiquement, tu aura d'autres problèmes tels que la localisation, la disponibilité des autres machines, comment les adresser et gérer les erreurs. Sinon, ça me parait viable, je crois même que c'est un pattern qui porte le nom de "Business delegate". Si tu peux avoir un mécanisme de communication asynchrone (type Reactor), tu peux même sauver un thread.
Pour une séparation complète, le pattern le plus simple est que les requêtes soit mises dans une queue dont les éléments sont consumés par un thread qui dispatch l'exécution soit dans un thread local soit à une machine distante. Ton abstraction n'est donc plus le thread mais un pipe d'exécution de méthodes. A ces méthodes est associée une "Future", c'est à dire l'instance d'une classe qui gère le retour de données asynchrones (typiquement tu peux demander si le résultat est arrivé ou tu peux l'attendre pendant un temps donné).
Pour une étude en profondeur, tu peux consulter le POSA4 qui concerne la distribution de calculs.
Tu peux aussi voir tout ce qui est MPI pour du traitement distribué.
