Discussion :

[Tux++]

Bonjour à tous,

je ne sais pas exactement si je suis dans la bonne section, tout du moins, voici ma question.

Nous devons implémenter une sorte de povray distribué.

un dispatcher envoi une image à plusieurs workers, chaque worker calculer une partie du rendu grâce à un fichier .pov et povray et le tout est renvoyé au dispatcher (en gros).

Je me demandais quels algorithmes ou quelles façon de penser existait-il au niveau du nombre de fragment d'image à générer par les workers...Si je découpe en trop, povray doit être appelé à chaque rendu et donc perte d'efficacité mais en pas assez je risque par exemple d envoyer un ciel bleu a un worker et une cathédrale à lautre si l'image n'a pas une complexité uniforme...

voilà si vous avez des idées,

merci

[Tux++]

Pour être plus clair, je souhaite à partir d'un fichier .pov:

- Générer un rendu povray mais de manière distribuée càd:

1*/ Chaque "worker" va lancer la commande povray sur le .pov mais de tel pixel à tel pixel (càd une division en fragments attribués à chaque worker)

j'aimerai savoir si vous avez une idée de division efficace en fonction de n workers ou s'il existe des algos de type répartition de la charge de rendu d'une image

[pseudocode]

Généralement, on se débrouille pour envoyer a chaque worker des zones de complexité égales. Cela implique de pré-calculer la compléxité avant de faire le rendering.

Le plus simple consiste a découper l'images en carrés et calculer la complexité moyenne de chaque carré, par exemple en comptant le nombre d'intersections potentielles dans le carré (= nombre d'objets dans le Z-Buffer) divisé par la surface. On envoie ensuite aux workers des listes de carrés dont les temps de calculs sont équivalents ( = somme { complexité_carré * surface_carré } ).

Bien sur, on peut affiner le calcul en ajoutant l'influence d'autres informations de la scène (textures, reflets, ...), ou des workers (CPU, mémoire, ...)