Globals init, glbl_sp, glbl_ss, glbl_bp and glbl_fc are used during initialization to store current register information, and to pass the routine to be used by the process to the task handler. systimer points to the memory location of the system clock. postlist points into the circular list of posts, and generally points to the last post to be used. totalposts records the number of posts that have been created in the system up to this point; there is no way to delete posts.

The second part of initialization occurs once simulation has started. At this time, _sim_init_val is 0, and the structure field init is 1. These flags cause the task_handler to load the code segment and instruction pointer registers with values pulled out of the fields in the structure and the field init is set to 0. After the interrupt return has completed, the process starts executing as though it were called from another routine. At this point the process is up and running on its own.

stop_process is called when a process must be destroyed. This routine finds the _simprocessT structure for the process to be stopped and sets the field status.kill_flag to 1. After stop_process has changed the value of status.kill_flag for that process, the task_handler removes the offending process from the list of processes and frees its memory.

At each transfer of control, task_handler looks for the next process to be given control. It can decide in one of three ways. If a key has been pressed, task_handler automatically passes control to the keyboard routine (assuming one has been designated with start_kb_process). If there are no pending keystrokes and _sim_time_ratio is 0, task_handler will start the process with the lowest value of start_time and advances _sim_system_time to match start_time. If _sim_time_ratio is not 0, the difference between now and the last time update is multiplied by _sim_time_ratio and added to _sim_system_time. The process (if any) with a start_time less than or equal to _sim_system_time becomes the current process, and _sim_system_time is set to start_time. If no process has a start_time less than or equal to _sim_start_time, task_handler continues to loop through the list of processes while actual system time goes by, updating _sim_system_time at the rate of _sim_time_ratio until a processes start_time is reached.

The last system control routines are sim_start and exit_processing. sim_start starts the actual simulation processes by setting the global variable init to 0. An interrupt is then executed to start task_handler. The routine exit_processing cleans up after the simulation library and may additionally signal any errors on exit. To shut down the simulation system, the interrupt that was initially changed to hold the address of task_handler is returned to the value in old_vector. Finally, all the process and post memory structures are freed.

The process control routines are start_kb_process, start_process and stop_process. The major difference between the routines start_kb_process and start_process is that start_kb_process signals to task_handler that the process it is about to initialize is to be the designated keyboard handler. These routines ensure that the task_handler has been installed and allow it to perform the first level of initialization.

The start_kb_process and the start_process routines call getvect ( ) to determine if the task_handler has been installed. getvect( ) checks that the address of the selected interrupt is the same as the address of task_handler. If the returned address is not the same as task_handler, then install_handler is called to install task_handler.

When start_kb_process and start_process set up a process, they allocate memory equal to the size of a _simprocessT structure plus a stack (sized in paragraphs). The address of the structure is normalized as it would be in a huge memory model program. The stack segment is set to the normalized segment address of the structure, and the stack and base pointers are set to the normalized offset address of the structure, plus the size of the stack in bytes, establishing the stack space as a unique piece of memory for each process.

The code segment and instruction pointer fields of the _simprocessT structure for the current process are set to point to the beginning of the routine to be used by the process. Next, the new structure is spliced into the processlist. Finally, these routines save the current stack and base pointers in global variables, set the actual stack and base pointers to the newly-created stack, call task_handler to initialize the process structure, and clean up the stack and base pointers from global variables.

stop_process is one of the simpler routines since task_handler performs the majority of the operations required to kill a process. stop_process merely finds the correct _simprocessT structure and sets the status.kill_flag to 1.

The routines wait_until_time and wait_for_time directly control timing of processes. wait_until_time determines the interval between the current time and the desired start time. If the interval is negative, exit_processing is called with an appropriate number. If the interval is positive, then wait_until_time calls wait_for_time to request the delay. wait_for_time determines the time to wake the process, sets the process's start_time and then executes an interrupt to task_handler. task_handler waits until _sim_system_time is equal to the process's start time before returning control to the process.

init_post can produce a new post or verify the existence of an old post. When called, init_post checks all existing posts to determine if the incoming string argument names an existing post. If so, the ID for the matching post is returned to the calling process. If no post exists for that name, a new post with initial values set to NULL is linked into the list of posts. The new post's ID number is returned to the calling routine.

set_post is more complicated than init_post.set_post searches the list of posts for one with the proper ID. If the candidate post is currently set, a zero time wait is performed, allowing a simultaneous read of the old value to occur. If the value is still set, the routine returns the ID of the post to signal the error. Otherwise, the value address is set to the address supplied by the user.

If one or more processes are waiting for this post, the status.wait_flag field in the first waiting process structure is assigned 0, notifying task_handler that the process has started. Additionally, any processes found waiting on this post are placed into the NULL-terminated array of process pointers linked to the _postT structure.

get_post searches the list of posts for one with the appropriate ID. If the matching post's value field is NULL, get_post returns NULL, signifying that the post is not set. Otherwise, get_post returns the address stored in value.

wait_post functions much like get_post, but when wait_post encouters a NULL value field, it sets the process's status.wait_flag to 1, signaling task_handler to ignore this process. The post's address is placed in the process structure's waitpost field, and the address of the process is placed in the _postT's waiting array. wait_post then waits for the value field of the post to become something other than NULL. When this occurs, the post value is NULLed and returned to the calling program. The process status.wait_flag is then set to 0 and normal processing continues.

int start_kb_process (void
   (*func)(void),int stacksize);
int start_process (void
   (*func)(void), int stacksize);

int set_time_ratio (float ratio);

void sim_start (void);

void exit_processing (int condition);

void stop_process (int process_id);

int wait_until_time
   (long unsigned starttime);

int wait_for_time (float delaytime);

int init_post  (char *postname);

int set_post  (int post_id, void * pointer);

void *get_post  (int post_id);

void *wait_post  (int post_id);

Ideally, a resource can be requested by multiple processes at the same time, and actually delivered to a particular process based on some prioritization scheme, either FIFO or FIFO by priority, or whatever scheme is appropriate.

A crude method of performing this scheme is to use set_post and wait_post inside another routine to allocate and deallocate resources from processes, and to use a global variable to track how many of the resources are available at any one time.