threads à l'intérieur d'un fil?

Je veux mettre en œuvre diviser et conquérir l'aide de pthread, mais je ne sais pas ce qui va se passer si je créer plusieurs threads dans un thread.

À partir de ma compréhension, si la machine dispose d'un processeur 2-coeur, il ne peut traiter que 2 threads en même temps. Si il y a plus de 2 threads, les autres threads avoir à attendre pour les ressources, donc si j'ai créer plus de plus en plus de fil alors que je vais plus profond, en fait, il ne peut pas augmenter la vitesse de l'algorithme depuis seulement 2 threads peuvent être traitées en même temps.

Je fais un peu de recherche en ligne et il semble que les fils au niveau supérieur peut être inactif, seules celles qui sont au niveau le plus profond de rester actif. Comment atteindre cet objectif? Aussi, si un fil supérieur reste inactive, elle affecte la canette?

"il semble que les fils au niveau supérieur peut être inactif, seules celles qui sont au niveau le plus profond rester actif" - est-ce une fonctionnalité que vous voulez, ou un état de fait? Si c'est une déclaration de fait, il n'est pas vrai. Au moins, il n'est pas vrai, sauf si vous écrivez du code pour obtenir la haute threads pour devenir "inactif".
Je suis curieux de savoir: quel problème que vous souhaitez résoudre, et de quelle manière? Pourquoi pensez-vous que de niveau supérieur peuvent être inactif est utile pour faire cela?
c'est un état de fait, mais je ne sais pas comment faire pour y arriver. si le haut de son fils dormir, ne les threads ils se reproduisent continuer à s'exécuter?
pas de problème exact, mais je peux donner un exemple simple, mergesort. depuis dans mergesort on peut se concentrer uniquement sur le niveau le plus profond, im me demandais si on peut faire la partie supérieure de threads inactifs, de sorte que le processeur peut traiter les fils au niveau plus profond.
Le truc c'est: le frai fils coûts de cycles. Si un thread génère 2 enfants et puis s'en va dormir en attente pour eux de revenir, au lieu de cela il est moins cher de spawn 1 seul thread, et ensuite faire le travail de l'autre thread lui-même.

OriginalL'auteur Tony | 2012-05-15

c pthreads

5

Il y a deux types de base: détaché et juxtaposables.

Un recrutables fil en est un qui peut vous attendre (ou accéder à la suite de l') résiliation à l'aide de pthread_join.

À l'aide de plus de threads qu'il y a des cœurs peuvent aider ou blesser -- dépend de votre programme! Il est souvent bon de réduire ou d'éliminer la concurrence pour les ressources avec le multithreading. Jeter trop de threads à un programme peut effectivement ralentir le processus. Cependant, vous aurait probablement temps d'inactivité du PROCESSEUR si le nombre de cœurs correspond au nombre de threads et l'un des threads en attente d'e /s de disque (à condition que rien d'important qui se passe dans d'autres processus).

threads au niveau supérieur peut être inactif, seules celles qui sont au niveau le plus profond de rester actif. comment atteindre cet objectif?

À l'aide de recrutables threads, vous pouvez accomplir la imbriquée fil de l'approche que vous avez décrite, et cela est démontré dans plusieurs tutoriels. Le flux de base est qu'un thread va créer un ou plusieurs travailleurs, et attendre pour eux de sortie à l'aide de pthread_join. Cependant, les solutions de rechange telles que des tâches et des pools de threads sont préférables dans la majorité des cas.

Néanmoins, il est peu probable que cette approche est la meilleure pour l'exécution, parce qu'il n'est pas en corrélation (bien) avec le matériel et la planification des opérations, en particulier la profondeur et la largeur de votre programme augmente.

si un fil supérieur rester inactif, n'affectera pas le fil inférieur?

Oui. Le problème typique, cependant, est que le travail/les threads ne sont pas limitées. L'utilisation de l'approche que vous avez décrit, il est facile de spawn de nombreux fils et ont une illogiquement haute nombre de threads pour le travail qui doit être exécuté sur un nombre limité de cœurs. Par conséquent, votre programme devrait déchets beaucoup de temps de changement de contexte et d'attente pour les threads pour terminer. La création de plusieurs threads peuvent également des déchets/réserve une quantité importante de ressources, surtout si elles sont de courte durée et/ou en veille/attente.

donc, si je créer de plus en plus de threads alors que im aller plus loin, en fait, il ne peut pas augmenter la vitesse de l'algorithme depuis seulement 2 threads peuvent être traitées en même temps.

Qui suggère la création de threads à l'aide de cette approche est erronée. Vous souhaitez peut-être créer un petit nombre de threads au lieu de cela, et d'utiliser une approche basée sur les tâches, où chaque thread demandes et exécute des tâches à partir d'une collection. Création d'un thread prend un bon peu de temps et de ressources.

dire si la machine a 2 core et j'ai créer 2 threads dans main() et je veux créer plus de threads dans chaque thread. si j'ai utilisé rejoint fil, les ressources seront disponibles pour les sous-threads?
Vos questions ne font pas de sens. Je soupçonne qu'il y a de nombreux malentendus sous la surface. (Par exemple, les "ressources" êtes-vous en train de parler?!)
Les types sont détachés et recrutables, n'a pas adhéré. Et un recrutables fil est l'un que l'autre thread attendez, pas un de ceux que lui-même attend. Et il n'y a pas une telle chose comme "ses enfant(s)". N'importe quel thread qui souhaite peut attendre de tout autre recrutables thread dans le processus. Et à la fois détaché et juxtaposables les threads s'exécutent en parallèle le fil qui les a engendrés depuis le thread qui a engendré un thread est totalement hors de propos. Il n'y a pas de relation particulière entre un fil et la ponte fil.
si je pose des questions idiotes, je ne m'en excuse, je suis encore à apprendre ces trucs dans l'uni. se référant "ressources", je veux dire de l'UC...
Vous encore dire que recrutables threads sont dépendants sur le thread qui a créé alors qu'il y a aucun relation particulière entre un fil et le fil qui l'a créé. Toute autre thread dans le processus peuvent se joindre, ou de se détacher, un recrutables fil.

OriginalL'auteur justin

Si vous essayez de le faire dans les deux sens de diviser et de conquor, la ponte de deux enfants et d'attente pour eux à la fin, vous avez probablement besoin de quelque chose comme:

void *
routine (void * argument)
{
  /* divide */
  left_arg = f (argument);
  right_arg = f (argument);

  /* conquor */
  pthread_create (left_child, NULL, routine, left_arg);
  pthread_create (right_child, NULL, routine, right_arg);

  /* wait for 'children' */
  pthread_join (left_child, &left_return_val);
  pthread_join (right_child, &right_return_val);

  /* merge results & return */
}

Une légère amélioration ne serait-ce, où, au lieu de dormir, le "parent thread" fait le travail de l'enfant de façon synchrone, et engendre un de moins thread:

void *
routine (void * argument)
{
  /* divide */
  left_arg = f (argument);
  right_arg = f (argument);

  /* conquor */
  pthread_create (left_child, NULL, routine, left_arg);
  /* do the right_child's work yourself */
  right_return_val = routine (right_arg);

  /* wait for 'left child' */
  pthread_join (left_child, &left_return_val);

  /* merge results & return */
}

Cependant, quand vous allez à N niveaux de profondeur, vous avez tout à fait un peu d'enfants. L'accélération obtenue dépend vraiment de combien de temps le CPU passe sur une véritable transformation, et combien de temps il attend pour les I/O etc. Si vous savez que sur une machine avec P cœurs, vous ne pouvez obtenir une bonne accélération, dire kP fils, alors au lieu de frai fils comme ci-dessus, vous pourriez mettre en place un " travailleur de la piscine " de kP fils, et de garder les réutiliser. De cette façon, une fois kP threads ont vu le jour, vous ne spawn plus:

THREAD_POOL pool = new_thread_pool (k * P); /* I made this function up */

void *
routine (void * argument)
{
  /* divide */
  left_arg = f (argument);
  right_arg = f (argument);

  /* conquor */
  left_thread = get_worker (pool); /* Blocks until a thread is free  */
  /* get left_thread to do processing for you */

  right_thread = get_worker (pool); /* Blocks until a thread is free  */
  /* get right_thread to do processing for you */

  /* wait for 'children' */
  pthread_join (left_child, &left_return_val);
  pthread_join (right_child, &right_return_val);

  /* return the workers */
  put_worker (pool, left_thread);
  put_worker (pool, right_thread);

  /* merge results & return */
}

Je trouve que le codage des exemples beaucoup plus instructif que la théorie de Justin réponse (et les commentaires ci-dessous) - "image == 1000 mots" 🙂

OriginalL'auteur ArjunShankar

0

Vous devriez être en mesure de créer beaucoup plus de threads que vous avez des cœurs de votre système. Le système d'exploitation va faire en sorte que chaque fil reçoit qu'une partie de la CPU pour faire son travail.

Cependant, il est [probablement] une limite supérieure pour le nombre de threads que vous pouvez créer (consultez la documentation de votre système d'exploitation).

Donc, si vous créez 5 threads dans un système avec 2 noyaux, puis chaque thread va obtenir environ 40% de la cpu (en moyenne). Ce n'est pas qu'un thread a plus qu'à attendre jusqu'à ce qu'un autre thread a complètement terminé. Sauf si vous utilisez des verrous en cours.

Lorsque vous utilisez des verrous pour protéger les données d'être modifiées ou accessibles par plusieurs threads, un certain nombre de problèmes peuvent apparaître. Les problèmes typiques sont:
- les serrures: 1 thread attend sur quelque chose qui est verrouillé par le thread 2; filetage 2 attend sur quelque chose qui est verrouillé par le thread 1
- de verrouillage convoi: plusieurs threads sont tous en attente sur la même serrure
- inversion de priorité: 1 thread a la priorité sur le thread 2, mais depuis le thread 2, équipé d'une serrure, la plupart du temps, le thread 1 encore a attendre sur le thread 2
J'ai trouvé cette page (http://ashishkhandelwal.arkutil.com/index.php/csharp-c/issues-with-multithreaded-programming-part-1/), qui pourrait être un bon début sur la programmation multithread.

OriginalL'auteur Patrick

Vous devez vous connecter pour publier un commentaire.