Wait-free cache-affinity thread scheduling

2003 ◽  
Vol 150 (2) ◽  
pp. 137 ◽  
Author(s):  
K. Debattista ◽  
K. Vella ◽  
J. Cordina
Keyword(s):  
Thread Scheduling ◽  
Cache Affinity

A Layered Mapping of Ada 202X to OpenMP

2021 ◽  
Vol 40 (2) ◽  
pp. 55-58
Author(s):  
S. Tucker Taft
Keyword(s):  
Operating System ◽  
Application Programming Interface ◽  
Light Weight ◽  
Main Interest ◽  
Thread Scheduling ◽  
Environment Variables ◽  
Application Programming ◽  
Parallel Loops ◽  
Programming Interface

The OpenMP specification defines a set of compiler directives, library routines, and environment variables that together represent the OpenMP Application Programming Interface, and is currently defined for C, C++, and Fortran. The forthcoming version of Ada, currently dubbed Ada 202X, includes lightweight parallelism features, in particular parallel blocks and parallel loops. All versions of Ada, since its inception in 1983, have included "tasking," which corresponds to what are traditionally considered "heavyweight" parallelism features, or simply "concurrency" features. Ada "tasks" typically map to what are called "kernel threads," in that the operating system manages them and schedules them. However, one of the goals of lightweight parallelism is to reduce overhead by doing more of the management outside the kernel of the operating system, using a light-weight-thread (LWT) scheduler. The OpenMP library routines support both levels of threading, but for Ada 202X, the main interest is in making use of OpenMP for its lightweight thread scheduling capabilities.

Benefits of cache-affinity scheduling in shared-memory multiprocessors

1993 ◽  
Vol 21 (1) ◽  
pp. 272-274 ◽  
Author(s):  
Josep Torrellas ◽  
Andrew Tucker ◽  
Anoop Gupta
Keyword(s):  
Shared Memory ◽  
Shared Memory Multiprocessors ◽  
Cache Affinity

Scheduling for cache affinity in parallelized communication protocols

1995 ◽  
Vol 23 (1) ◽  
pp. 311-312 ◽  
Author(s):  
James D. Salehi ◽  
James F. Kurose ◽  
Don Towsley
Keyword(s):  
Communication Protocols ◽  
Cache Affinity

Fairness in Agent Based Simulation Frameworks

2008 ◽  
Author(s):  
Lawrence Welch ◽  
Stephen Ekwaro-Osire
Keyword(s):  
Initial Conditions ◽  
Scheduling Algorithm ◽  
Random Order ◽  
Multiple Agents ◽  
Agent Based Simulation ◽  
Time Step ◽  
Thread Scheduling ◽  
Agent Based ◽  
Simulation Engine ◽  
Over Time

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.

A control-theoretical approach to thread scheduling for multicore processors

2015 ◽  
Author(s):  
Alessandro Vittorio Papadopoulos ◽  
Roberto Carone ◽  
Martina Maggio ◽  
Alberto Leva
Keyword(s):  
Theoretical Approach ◽  
Multicore Processors ◽  
Thread Scheduling
Sign in / Sign up

Export Citation Format

Share Document