Simulation Programming Notes

Simula class DEMOS includes objects for the following 4 typical patterns of synchronization.

Producer - Consumer synchronization

Consumers synchronize with producers by means of a queue, or "bin." Producers can produce if there is room in the bin. (They can always produce if the bin is unlimited.) Consumers can consume only when the bin is not empty. The simplest form of a bin is simply a counter of anonymous items. Often we want to use a fifo-queue of the desired items, such as customers with arrival times, busses with number of passengers, or messages with text.

Using our toolboxes, the unit QUEUE can be used to hold the desired items, or the unit QNETOBJ to hold TArecords.

SIMULA class DEMOS (Discrete-Event Modeling On SIMULA) provides, among other things, the type bin, of anonymous counters. Producers give units of production (integer parameter) to the bin, and Consumers take units. A bin is initialized with a name (string) as a standard feature of DEMOS objects, and an initial content, for example:

        HappyCustomers :- new bin ("Happies", 0)

Limited-capacity resources -- Semaphores

If the resource has capacity of one, we call it a single server. This special case is probably easier to deal with.

For example, in GPSS a single server is modeled by a facility. A facility can be seized and released, preempted, and made unavailable (with several degrees of urgency). A check is made that the same transaction releases a facility was the one that seized it. By contrast, a resource with larger capacity is modeled as a storage, transactions can enter and leave it. New entries can be blocked, but that is all.

The concept of semaphore comes from operating systems. A semaphore is a special counter that allows only a certain number of processes to be within a critical section at one time. The critical section of a process is guarded by calls to wait and signal on the semaphore. Wait allows the process to pass, so long as the counter value is greater than 0. It then decrements the value. If not, the semaphore needs to hold up (block) the process, using a queue for this purpose. Signal increments the value, letting new processes pass their wait instruction. In simulation, we would typically use a semaphore to guard a section

• Wait
• SeizeServer
• Sleep for service time
• ReleaseServer
• Signal

• Try to acquire more units, blocking those behind, or
• Let other processes with lighter requests go first - this can lead to starvation
• Acquire what you can, and then go back and wait for more - this is an invitation to deadlock with other processes playing the same game.

Condition queues

SIMULA class DEMOS provides a powerful class condq at which processes wait upon arbitrary conditions. Each time the condq is signaled (by processes completing their services (critical sections), the conditions of the waiting processes are reevaluated to see which one(s) can proceed. There is the option to evaluate either the first waiting process, or all of them. It would be an interesting project to implement this scheme in Pascal. I believe it can be done by associating with each process a Boolean function.

Master-Slave synchronization