Listing 4 DEMO.C — demo code for SSX

*****************************************************/
/*     By Tom Green and Dennis Cronin               */
/*     10/19/92                                     */
/****************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <bios.h>
#include <conio.h>
#include "ssx.h"

/* vector for PC timer interrupt */
#define TIMER_INT_VEC           8
/* 18.2 clock ticks per second on PC */
#define TICKS_PER_SECOND        18L

#define NUM_PQ_TASKS            5
#define NUM_TS_TASKS            5

void key_task(void);
void print_ts_count_task(void);
void sys_time_task(void);
void ts_task(void);
void print_q_task(void);
void interrupt tick_handler(void);

unsigned int pq_task_counter=0;
unsigned int ts_task_counter=0;
wait_q print_q;
void interrupt (*old_timer_int)(void);
unsigned long pq_count[NUM_PQ_TASKS];
unsigned long ts_count[NUM_TS_TASKS];

void main(void)

{
   unsigned int i;

   clrscr();

   pq_task_counter=0;
   ts_task_counter=0;

   if((ssx_init()) == INIT_ERROR){
      printf("\nError initting SSX");
      exit(1);
   }

   /* set up timer tick interrupt handler */
   old_timer_int = getvect(TIMER_INT_VEC);
   setvect(TIMER_INT_VEC,tick_handler);

   /* install print q tasks */
   for(i = 1;i <= NUM_PQ_TASKS;i++){
      if((ssx_task_create(1,i,print_q_task,0x200,
                       "task"))!=SUCCESS)
         cprintf("\nError creating task %d",i);
   }
   /* install time slice tasks */
   for(i = NUM_PQ_TASKS + 1;i <= (NUM_TS_TASKS +
                          NUM_PQ_TASKS);i++){
      if((ssx_task_create(1,i,ts_task,0x200,
         "ts_task"))!=SUCCESS)
         cprintf("\nError creating ts task");
   }

   /* install print ts count task */
   if((ssx_task_create(1,22,print_ts_count_task,0x200,
      "pts_task"))!=SUCCESS)
      cprintf("\nError creating ts count task");
   /* install keypress task */
   if((ssx_task_create(1,21,key_task,0x200,
      "key_task"))!=SUCCESS)
      cprintf("\nError creating keypress task");
   /* install system time task */
   if((ssx_task_create(1,23,sys_time_task,0x200,
      "st_task"))!=SUCCESS)
      cprintf("\nError creating system time task");
   cprintf("\r\nDone creating tasks");
   cprintf("\r\nPress key to start SSX");
   bioskey(0);
   clrscr();
   SET_SEMAPHORE(&print_q);
   ssx_run();

   /* reset to old timer int handler */
   setvect(TIMER_INT_VEC,old_timer_int);

   clrscr();
}

/* ts_task - time slice task. this task gets a full
 *           time slice to increment counter.
 *           print_ts_count_task prints counters.  */

void ts_task(void)

{
   int task_num;

   task_num = ts_task_counter++;
   ts_count[task_num] = 0L;

   while(1){
   ts_count[task_num]++;
   }
}

/* print_q_task - this task waits for print q we have
 *                set up and then increments counter
 *                and prints and then releases print q */

void print_q_task(void)
{
   unsigned int y,task_num;

   task_num = pq_task_counter++;
   y = task_num + 1;
   pq_count[task_num] = 0L;

   while(1){
      ssx_wait(&print_q);
      pq_count[task_num]++;
      gotoxy(1,y);
      cprintf("Task   %02d %08lx",task_num,

             pq_count[task_num]);
      ssx_alert(&print_q);
   }
}

/* print_ts_count_task - task that prints counts
 *                       from time sliced tasks
 *                       once every 3 seconds */

void print_ts_count_task(void)
{
   int task_num;

   while(1){
      ssx_wait(&print_q);
      for(task_num = 0;task_num < NUM_TS_TASKS;
         task_num++){
         gotoxy(1,task_num + NUM_TS_TASKS + 1);
         cprintf("TS Task %02d %08lx",task_num,
                ts_count[task_num]);
      }
      ssx_alert(&print_q);
      ssx_task_delay(3 * TICKS_PER_SECOND);
   }
}

/* key_task - task that checks for keypress every
 *            2 seconds. calls ssx_stop when key
 *            is pressed                            */

void key_task(void)
{
   while(1){
      if((bioskey(1)) != 0){
         bioskey(0);
         ssx_stop();
      }
      ssx_task_delay(2 * TICKS_PER_SECOND);
   }
}

/* sys_time_task - prints how long it has been
 *                 running once every minute */

void sys_time_task(void)
{
   int task_num;

   while(1){
      ssx_wait(&print_q);
      gotoxy(1,15);
      cprintf("Sytem time = %08lx seconds",
          ssx_get_time()/ TICKS_PER_SECOND);
      ssx_alert(&print_q);
      ssx_task_delay(1 * TICKS_PER_SECOND);
   }
}

/* tick_handler - handles 18.2 per second timer
 *                interrupts on PC                */

void interrupt tick_handler(void)
{
   /* call original PC timer handler */
   (*old_timer_int)();
   /* inform SSX of clock tick */
   ssx_clock_tick();
}
/* End of File */