An agent based simulation engine should provide a fair playing field for all of its agents. A fundamental design axiom of agent based simulation frameworks is that the simulation engine should not arbitrarily bias its execution towards one agent or another. This fairness is basic to giving the agent modeler confidence that differences in behavior and performance between agents derive legitimately from the simulation modeling, initial conditions or specific agent characteristics, rather than the capriciousness of the underlying framework. One aspect of fairness in a simulation is the relative order of execution of agents over time. This order of execution is affected by techniques employed by frameworks to simulate the concurrent activities of multiple agents. One such technique is multi-threading. Multi-threaded operating systems, or programming languages and environments, such as Java, allow multiple agents, represented by software threads, to share the computer’s execution time by taking turns, thus appearing to act simultaneously. The precise order of execution of peer threads in multi-threaded applications is often out of the hands of the programmer, and may be determined exclusively by the operating system or program execution environment. However, if overlooked by the framework developer, the idiosyncrasies of a particular thread ordering mechanism can pass on to the modeler inherent random behavior that is neither intuitive, nor in line with the modeler’s expectations. To be considered fair, the engine should aim to provide all agents with equal probability of executing first within a time step, or last, or in any position in between. This paper analyzes the sequencing of agent thread execution within a Java framework that implements a multi-threaded, time-stepping, agent based simulation engine. The natural ordering of Java thread execution is demonstrated to be unfair (that is, not uniform) in its treatment of agents. This research shows that the standard mechanism of Java thread scheduling, while appropriate for most applications, is inappropriate on its own for the agent based framework. It is demonstrated that with Java’s standard thread scheduling algorithm, over time certain agents tend to execute ahead of others within each time step, while others tend to execute in the middle or at the back of the pack. This paper then introduces and demonstrates the “Uniform Specific Notification” pattern, a technique that produces a fairer, uniformly distributed random order for the initial execution of Java agent threads at each simulation time step.
The algorithm of thread scheduling with an Improvement Accelerating Critical Section of migration strategy
