opengl: glFlush() vs glFinish()

Question

Je vais avoir de la difficulté à distinguer la différence pratique entre un appel glFlush() et glFinish().

Les docs disent que glFlush() et glFinish() va pousser tous les tamponnée opérations à opengl de sorte que l'on peut être assuré qu'ils seront tous exécutés, la différence étant que glFlush() retourne immédiatement, où que glFinish() bloque jusqu'à ce que toutes les opérations sont terminées.

Après avoir lu les définitions, j'ai pensé que si je devais utiliser glFlush() que j'aurais probablement courir dans le problème de la soumission des opérations à openGL qu'il pourrait s'exécuter. Donc, juste pour essayer, j'ai troqué mon glFinish() pour un glFlush() et voilà, mon programme est exécuté (autant que je puisse en juger), exactement le même; taux de rafraîchissement, de l'utilisation des ressources, tout était le même.

Alors je me demandais si il y a une grande différence entre les deux appels, ou si mon code ne fait courir aucun différent. Ou l'endroit où il devrait être utilisé contre l'autre. J'ai aussi pensé que openGL aurait certains appellent comme glIsDone() pour vérifier si oui ou non tous de la mémoire tampon des commandes pour un glFlush() sont complètes ou pas (donc on n'est pas d'envoyer des opérations d'openGL plus vite qu'ils ne peuvent être exécutées), mais j'ai pu trouver pas une telle fonction.

Mon code est le jeu typique de la boucle:

while (running) {
    process_stuff();
    render_stuff();
}

Answer 1

L'esprit que ces commandes existent depuis les premiers jours de l'OpenGL. glFlush assure que les précédentes commandes OpenGL doit remplir en un temps fini (OpenGL 2.1 spécifications, page 245). Si vous dessinez directement sur le front de la mémoire tampon, ce veillent à ce que les pilotes OpenGL commence le dessin sans trop de retard. Vous pourriez penser à une scène complexe qui apparaît objet après objet sur l'écran, lorsque vous appelez glFlush après chaque objet. Cependant, lors de l'utilisation de la double mise en tampon, glFlush a pratiquement aucun effet, puisque les modifications ne seront pas visibles jusqu'à ce que vous permutez les tampons.

glFinish ne pas revenir jusqu'à ce que tous les effets de prviously émettre des commandes [...] soient pleinement réalisés. Cela signifie que l'exécution de votre programme attend ici jusqu'à ce que chaque pixel est dessiné et OpenGL n'a plus rien à faire. Si vous rendre directement sur le front de la mémoire tampon, glFinish est l'appel à faire avant d'utiliser le système d'exploitation appelle pour prendre des captures d'écran. Il est beaucoup moins utile pour le double buffering, parce que vous ne voyez pas les modifications que vous avez forcé à compléter.

Donc, si vous utilisez une double mise en mémoire tampon, vous n'aurez probablement pas besoin ni glFlush ni glFinish. SwapBuffers implicitement dirige les appels OpenGL pour le tampon approprié, il n'y a pas besoin d'appeler glFlush premier. Et n'avez pas l'esprit en soulignant le pilote OpenGL: glFlush ne va pas s'étouffer trop de commandes. Il n'est pas garanti que cet appel retourne immédiatement (quoi que cela signifie), de sorte qu'il peut prendre n'importe quel moment elle a besoin pour traiter vos commandes.

Answer 2

Les autres réponses ont laissé entendre, il n'y a vraiment pas de bonne réponse que par la spécification. L'objectif général de l' glFlush() , c'est que après l'appel, le PROCESSEUR de l'hôte n'aura pas d'OpenGL liés au travail à faire, les commandes ont été poussés à le matériel graphique. L'objectif général de l' glFinish() c'est qu'après il retourne, pas de travail restant est à gauche, et les résultats devraient être disponibles aussi tous les non-OpenGL Api (par exemple lit à partir de la mémoire vidéo, captures d'écran, etc...). Si c'est vraiment ce qui se passe est dépendant du pilote. La spécification permet une tonne de latitude quant à ce qui est légal.

Answer 3

Si vous ne voyez aucune différence de performance, cela signifie que vous faites quelque chose de mal. Comme certains d'autres l'ont mentionné, vous n'avez pas besoin de l'appeler, mais si vous le faites appel glFinish, alors vous êtes automatiquement perdre le parallélisme que le GPU et le CPU peut atteindre. Permettez-moi de plonger plus en profondeur:

Dans la pratique, tout le travail que vous soumettez pour le conducteur est mis en lots, et envoyé le matériel potentiellement plus tard (par exemple, au SwapBuffer temps).

Donc, si vous êtes d'appel glFinish, vous êtes essentiellement en forçant le pilote à pousser les commandes pour le GPU (qu'il groupées jusqu'alors, et n'a jamais demandé le GPU de travail), et de décrochage de la CPU jusqu'à ce que les commandes poussé sont complètement exécuté. Donc, pendant tout le temps le GPU fonctionne, le CPU n'a pas (au moins sur ce fil). Et toutes les fois que le CPU fait son travail (surtout le dosage, commandes), le GPU n'est pas n'importe quoi. Donc oui, glFinish devrait nuire à votre performance. (C'est une approximation, car les conducteurs commencent à avoir le GPU de travail sur certaines commandes si beaucoup d'entre eux ont déjà été ajoutés au mélange. Ce n'est pas typique, cependant, que la commande de tampons ont tendance à être assez grande pour contenir beaucoup de commandes).

Maintenant, pourquoi le feriez-vous appel glFinish à tous, alors ? La seule fois où j'ai utilisé c'était quand j'avais des bogues. En effet, si l'une des commandes que vous envoyez vers le bas pour les pannes de matériel de la carte graphique, puis votre option la plus simple pour identifier la commande qui est le coupable est l'appel de glFinish après chaque Tirage. De cette façon, vous pouvez affiner ce qui déclenche exactement le crash

Comme une note côté, l'Api comme Direct3D ne prennent pas en charge une Finition concept à tous.

Answer 4

Jetez un oeil ici. En bref, il dit:

glFinish() a le même effet que glFlush(), avec l'ajout que glFinish() bloque jusqu'à ce que toutes les commandes présentées ont été exécutés.

Un autre article décrit d'autres différences:

• Swap fonctions (utilisé en double buffer applications) automatiquement valider les commandes, donc pas besoin de faire appel glFlush
• glFinish forces OpenGL pour effectuer les commandes en suspens, ce qui est une mauvaise idée (par exemple, avec le VSync)

Pour résumer, cela signifie que vous n'avez même pas besoin de ces fonctions lors de l'utilisation de la double mise en tampon, sauf si votre swap-tampons de mise en œuvre n'est pas automatiquement valider les commandes.

Answer 5

glFlush vraiment remonte à un client-serveur modèle. Vous envoyez tous les gl commandes par l'intermédiaire d'un tuyau à un gl serveur. Le tuyau peut-tampon. Tout comme n'importe quel fichier ou d'un réseau i/o peut-tampon. glFlush dit seulement: "envoyer le tampon maintenant, même si elle n'est pas encore pleine!". Sur un système local, ce n'est presque jamais nécessaire, car un local OpenGL API est peu probable que la mémoire tampon et simplement des questions directement des commandes. Aussi toutes les commandes que la cause réelle de rendu va faire un implicite de la chasse d'eau.

glFinish d'autre part a été faite pour la mesure de la performance. Une sorte de PING pour les GL serveur. Il les allers-retours d'une commande et attend jusqu'à ce que le serveur répond "je suis libre".

De nos jours modernes, les automobilistes ont tout à fait les idées créatives de ce que cela signifie d'être inactif. Est-il "tous les pixels sont tracées" ou "ma commande file d'attente a l'espace"? Aussi parce que beaucoup de vieux programmes saupoudré glFlush et glFinish tout au long de leur code sans raison que le vaudou codage de nombreux drivers modernes il suffit de les ignorer comme une "optimisation". Ne pouvez pas les blâmer pour ça, vraiment.

Donc en résumé: pour Traiter à la fois glFinish et glFlush que pas d'ops dans la pratique, sauf si vous êtes codant pour une ancienne télécommande SGI OpenGL serveur.