Event Based Game Loop

[sholloway]

Create an Event Based Game Loop

Tasks

• [X] Basic task schedule loop.
• [X] Enforce not pegging the CPU at 100%.
• [X] Calculate and display the running schedule utilization.
• [X] Display the running frame rate.

EDF

This type of game loop leverages a priority queue to schedule future actions to occur. It is an instance of the Earliest deadline first (EDF) pattern.

The Basic Loop is of the Form

def main_loop(self, **data):
    previous_time: TimeInMS = TimeUtilities.now()
    lag: TimeInMS = 0

    while self.simulation_state is not SimulationState.ENDED:
      if self.simulation_state is SimulationState.RUNNING:
        current_time: TimeInMS = TimeUtilities.now()
        elapsed_time: TimeInMS = current_time - previous_time
        previous_time = current_time
        lag += elapsed_time

        process_input()

        while lag >= TIME_PER_UPDATE:
          self._scheduler.run(TIME_PER_UPDATE)
          lag -= TIME_PER_UPDATE

        render()

Resources

• Game Programming Patterns: Game Loop
• When should I use Fixed or Variable Time Step
• Efficient Event-based Simulations
• Fix your time step
• CPU Slicing

[sholloway]

Perhaps I should add the rolling utilization calculation as the game is running. That'll indicate how much head room the sim has for getting all the work done

This video breaks down calculating utilization and load for a scheduling algorithm.

As I'm digging into it, I realize that there is more to an EDF than just using a priority queue and running things based on their due time.

• I'm not addressing switching between a currently running task and a next due task.
• I have not considered deadlock conditions.
• The inner loop "while lag >= TIME_PER_UPDATE:" has me a bit concerned about power consumption and CPU costs to just keep checking for scheduled events. It's not clear to me yet what the best value for TIME_PER_UPDATE should be.

Consider the need to segment high criticality tasks from low criticality.

• A thought is to have the scheduler maintain multiple priority queues. This would be a partitioned scheduler.
• For the intended sims, where will this be a need? YAGNI.

I need a better simulation to get a sense for if my scheduling implementation is good enough. Thoughts:

• Dynamically calculate load and utility.
• Need a way to measure the DearPyGUI frame rate. I'm locking it with vsync. There may be a way to see it at the OS level.
• Have a controller for dynamically increasing the number of agents.
• Each agent should be performing some task.

Ideally, the same sim should existing using the other Simulation model.

[sholloway]

Are there existing EDF implementations in Python that I can study?