Re: CilkPlus

Pour le même genre d'algo c'est difficile à dire en fait. OpenMP définit les constructions paralleles, mais ne dit absolument rien à propos de l'ordonnancement (mis à part certaines grandes lignes pour l'ordonnancement des boucles parallèles). De l'autre cote, tu as Cilk qui décrit sous quelles conditions le vol de tache est effectué, le genre de structures de données utilisé pour stocker les piles de chaque thread dans le tas (cactus stack), le genre structures de données utilisé pour stocker les taches en attente (deque—double-ended queue), etc.

Bref, certaines implémentations d'OpenMP vont faire du vol de tache, d'autres vont avoir une file d'attente unique et centralisée (beurk), mais surtout, OpenMP n'a aucune garantie à apporter pour ce qui est de l'utilisation des ressources. Si j’écris un truc du genre

void fork_bomb(int n) {
 printf("%d-th iteration\n");
 if (n > 0) {
# pragma omp task
 {
 fork_bomb(n-1);
 }
# pragma omp task
 {
 fork_bomb(n-1);
 }
# pragma omp taskwait
 }
}
/* ou son equivalent Cilk */
cilk void fork_bomb(int n) {
 printf("%d-th iteration\n");
 if (n > 0) {
 spawn fork_bomb(n-1);
 spawn fork_bomb(n-1);
 sync;
 }
}

... dans un cas je peux potentiellement avoir 2^n taches créées (même si le taskwait limite quand même pas mal) alors qu'avec Cilk j'ai la garantie d'une exécution bornée en terme d'espace mémoire.

Par contre avec Cilk, tu es cense faire une synchro depuis la fonction appelante pour collecter les threads générés (ce qui garantit la propriété fully strict, qui nécessite qu'une tache fille se synchronise avec son parent direct), alors qu'OpenMP permet de faire a peu près tout, y compris du "strict-tout-court" (qui ne demande "que" d'avoir une tache qui se synchronise avec un ancêtre lorsqu'elle termine): tu peux créer une hiérarchie de taches, et ne demander à faire une synchro qu'avec une tache tout en haut de l'arbre de création.

Concernant Cilk+, j'ai regardé de plus près : ils ont une notation "à la Fortran" pour les tableaux, genre

int tab[MAX][MAX], a[MAX], b[MAX];
for (int i = 0; i < MAX; ++i) 
 tab[i] = 5;
// On peut raccourcir en ecrivant :
tab[0][:] = 5;
// On peut aussi faire des operations sur les tableaux : 
tab[:] = a[:] + b[:];

Ca marche pour les vrais tableaux et les conteneurs types "vecteurs" (i.e., un truc dont les bornes sont connues).

Apres, Cilk+ et TBB ou OpenMP ont des objectifs différents, et sont efficaces pour des classes problèmes différents, de ce que j'ai pige. Ça ne veut pas dire que tu ne peux pas faire une ch'tite multiplication de matrices efficacement en Cilk+, juste que faudra sans doute changer l'algo de partitionnement en blocs.