Dans le processus de développement d’un jeu vidéo, les équipes se heurtent à un problème majeur : les performances du jeu sur console et PC. En effet, les jeux AAA sont gourmands en puissance de calcul et ceux-ci doivent être capable de tenir au moins 30 images par seconde sur des consoles et 60 images par seconde sur des PC. Si le moteur de jeu échoue à construire les images à une cette fréquence, l'exécution devient saccadée ce qui impacte directement l'expérience du joueur. Afin de construire cette image, un ensemble de tâches doit être exécuté sur la machine d’un joueur à chaque frame, comme le moteur physique, la gestion du son, les intelligences artificielles. Chacune de ces tâches peut être exprimée de façon monolithique ou décomposée en un petit graphe parallèle. Elles sont regroupées sous forme d’un graphe global et doivent être exécutées efficacement afin de garantir un certain frame rate. Par ailleurs il est nécessaire de respecter les dépendances entre les tâches et leurs priorités afin de conserver à la fois une cohérence lors de l’exécution du jeu, mais également utiliser au mieux le temps disponible : cela veut dire qu’il faut utiliser efficacement la mémoire et le parallélisme de la machine. Une première difficulté réside dans le fait que ces tâches sont construites et ajoutées par des personnes différentes, dont les métiers sont indépendants. Le graphe de tâches global est obtenu par composition et est très difficilement accessible lors de la conception du jeu vidéo. Par ailleurs, le nombre de tâches et leur durée d’exécution varie au cours du déroulement du jeu en fonction de la position du joueur, de ses actions, de son environnement ou des autres joueurs. De plus la nécessité de respecter les contraintes de temps réel peuvent en fonction des ressources de calculs imposer l’utilisation de versions dégradées de certaines tâches voir complètement les abandonner. La redondance de motifs dans le graphe de tâches lors de l'exécution du jeu pourrait également nous pousser à anticiper certains calculs, et ainsi préparer en avance l’exécution de tâches nous permettant de meilleures performances. Il est donc nécessaire d’avoir un ordonnancement dynamique de tâches, capable de prendre ces différentes contraintes en compte. Dans cette thèse, nous analysons dans un premier temps l'impact de méthodes issue du calcul haute performance sur les moteurs de jeux, une formalisation du problème de l'ordonnancement temps réel souple dans le cadre du jeu vidéo, ainsi que les opportunités d’optimisation à partir de traces d’exécution collectées lors de parties. Nous proposons également une méthode d'ordonnancement dynamique, basés sur l’exploration d’un graphe de Monte Carlo afin de déterminer les optimisations locales possibles et ainsi adapter l’exécution de la Frame en fonction des besoins du jeu en priorisant les parties demandant le plus de ressources à un instant T de façon dynamique. De plus nous proposons aussi un mécanisme de "Task Skipping" dynamique, permettant de contrôler l’exécution du jeu en elle-même de façon à équilibrer la charge des différentes frames sur un temps plus long. Cela permet d’avoir une vision plus long terme de l’optimisation et de ne plus se borner à la frame mais à une espace local constitué de plusieurs, permettant de lisser les calculs et empêcher les pertes de frames, fréquentes lorsqu’un trop grand nombre de calculs sont nécessaires.