home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / drdobbs / 1986 / 12 / berry.dec next >
Text File  |  1986-12-31  |  64KB  |  1,814 lines
  1. /*
  2. Listing 1      Scheduling Algorithm
  3. (C) Copyright 1986 Ken Berry.
  4. All rights reserved.
  5. Copies may be made for non-commercial, private use only.
  6. */
  7.  
  8. #define _F 0             /* false */
  9. #define _T 1             /* true */
  10. #define _E -1            /* error */
  11.  
  12. #define _NULL 0          /* null pointer */
  13.  
  14. typedef char pointer;    /* pointer type */
  15. typedef char logical;    /* logical type */
  16. typedef unsigned selector; /* 8086 selector type */
  17.  
  18. struct sys_parm          /* register storage block for 8086 interface */
  19. {
  20.   union {unsigned sys_rax; struct {char sys_ral, sys_rah;} sys_byt;} sys_ra;
  21.   union {unsigned sys_rbx; struct {char sys_rbl, sys_rbh;} sys_byt;} sys_rb;
  22.   union {unsigned sys_rcx; struct {char sys_rcl, sys_rch;} sys_byt;} sys_rc;
  23.   union {unsigned sys_rdx; struct {char sys_rdl, sys_rdh;} sys_byt;} sys_rd;
  24. #define sys_ax sys_ra.sys_rax
  25. #define sys_al sys_ra.sys_byt.sys_ral
  26. #define sys_ah sys_ra.sys_byt.sys_rah
  27. #define sys_bx sys_rb.sys_rbx
  28. #define sys_bl sys_rb.sys_byt.sys_rbl
  29. #define sys_bh sys_rb.sys_byt.sys_rbh
  30. #define sys_cx sys_rc.sys_rcx
  31. #define sys_cl sys_rc.sys_byt.sys_rcl
  32. #define sys_ch sys_rc.sys_byt.sys_rch
  33. #define sys_dx sys_rd.sys_rdx
  34. #define sys_dl sys_rd.sys_byt.sys_rdl
  35. #define sys_dh sys_rd.sys_byt.sys_rdh
  36.   unsigned sys_bp;       /* base pointer */
  37.   unsigned sys_si;       /* source index */
  38.   unsigned sys_di;       /* destination index */
  39.   unsigned sys_sp;       /* stack pointer */
  40.   unsigned sys_cs;       /* code segment */
  41.   unsigned sys_ds;       /* data segment */
  42.   unsigned sys_ss;       /* stack segment */
  43.   unsigned sys_es;       /* extra segment */
  44.   unsigned sys_pf;       /* 80286 processor flags */
  45. #define SYS_OF 0x0800         /* overflow flag- 1: lost significance */
  46. #define SYS_DF 0x0400         /* direction flag- 1: strings auto-decrement */
  47. #define SYS_IF 0x0200         /* interrupt flag- 1: enable interrupts */
  48. #define SYS_TF 0x0100         /* trap flag- 1: interrupt every instruction */
  49. #define SYS_SF 0x0080         /* sign flag- 1: result negative */
  50. #define SYS_ZF 0x0040         /* zero flag- 1: result 0 */
  51. #define SYS_AF 0x0010         /* auxiliary carry flag- 1: carry from bit 3 */
  52. #define SYS_PF 0x0004         /* parity flag- 1: even number of 1's */
  53. #define SYS_CF 0x0001         /* carry flag- 1: carry from bit 8 or 16 */
  54.   unsigned sys_sw;       /* status word */
  55. #define SYS_TS 0x0008         /* task switch */
  56. #define SYS_EM 0x0004         /* processor extension emulation */
  57. #define SYS_MP 0x0002         /* monitor processor extension */
  58. #define SYS_PE 0x0001         /* protection enable */
  59.   unsigned sys_ip;       /* instruction pointer */
  60.   unsigned sys_res;      /* unused */
  61. };
  62.  
  63. struct t_xstck
  64. {
  65.   unsigned t_xbase;      /* application stack base (overflow detection) */
  66.   unsigned t_xes;        /* es */
  67.   unsigned t_xbp;        /* bp */
  68.   unsigned t_xdi;        /* di */
  69.   unsigned t_xsi;        /* si */
  70.   unsigned t_xdx;        /* dx */
  71.   unsigned t_xcx;        /* cx */
  72.   unsigned t_xbx;        /* bx */
  73.   unsigned t_xax;        /* ax */
  74.   unsigned t_xds;        /* ds */
  75.   unsigned t_xip;        /* ip */
  76.   unsigned t_xcs;        /* cs */
  77.   unsigned t_xpf;        /* pf */
  78.   unsigned t_retip;      /* return address */
  79. };
  80.  
  81. struct t_task
  82. {
  83.   char t_type;           /* task type */
  84. #define T_X 0x80         /* execute queue */
  85. #define T_W 0x40         /* wait queue */
  86. #define T_P 0x20         /* priority queue */
  87. #define T_SW 0x10        /* secondary wait queue */
  88. #define T_ATASK 0x01     /* abreviated task */
  89.   unsigned t_wttk;       /* wait tick count */
  90.   unsigned t_cls;        /* priority queue index */
  91.   struct t_task *t_pqtsk,*t_nqtsk; /* queue linkage */
  92.   struct t_task *t_ratsk,*t_pstsk,*t_nstsk,*t_fdtsk,*t_ldtsk; /* family */
  93.   struct sys_parm t_ps;  /* processor status */
  94.   unsigned t_xtm0;       /* execution time accumulator */
  95.   unsigned t_xtm1;
  96.   unsigned t_xtm2;
  97.   pointer *t_axstk;      /* execution stack pointer */
  98. };
  99.  
  100. extern pointer *sys_task; /* current task control table pointer */
  101. #define _tsk ( ( struct t_task * ) sys_task ) /* task control table ref */
  102.  
  103. #define T_SCLS 4         /* number of scheduling classes */
  104.  
  105. struct t_scls            /* scheduling class queue */
  106. {
  107.   unsigned t_sfrq;       /* scheduling frequency */
  108.   int t_sct;             /* queue length */
  109.   struct t_task *t_fqtsk,*t_lqtsk; /* queue header */
  110. };
  111.  
  112. struct t_schd            /* scheduling control table */
  113. {
  114.   int t_xct;             /* execution queue length */
  115.   struct t_task *t_fxtsk, *t_lxtsk; /* execution queue header */
  116.   int t_wct;             /* wait queue length */
  117.   struct t_task *t_fwtsk, *t_lwtsk; /* wait queue header */
  118.   int t_swct;            /* secondary wait queue length */
  119.   struct t_task *t_fswtsk, *t_lswtsk; /* secondary wait queue header */
  120.   int t_sclsl;           /* scheduling class index limit */
  121.   struct t_scls **t_sclsp; /* scheduling class array pointer */
  122. };
  123.  
  124. extern pointer *sys_tsch; /* task scheduling control table pointer */
  125. #define _tschd ( ( struct t_schd * ) sys_tsch ) /* quick pointer */
  126.  
  127. /*
  128. t__krnl                  /* security kernel */
  129. */
  130. t__krnl()
  131. /*
  132. This is the security kernel.  It never returns, being the most trusted
  133. software in the system. The current contents in t__crtss and t__crtsp
  134. are used to set the stack for when the current task is resumed. */ 
  135. { 
  136.   extern logical t_astrm; /* tick termination flag */
  137.   extern selector t__crtss; /* current task ss storage */
  138.   extern pointer *t__crtsp; /* current task sp storage */
  139.   extern unsigned tmr_tkct; /* tick clock */
  140.   int xtskct;            /* task queue count (at entry) */
  141.   int ttc;               /* task termination code */
  142.   _tsk -> t_ps.sys_ss = t__crtss; /* set current task stack */
  143.   _tsk -> t_ps.sys_sp = t__crtsp;
  144.   while(_T)              /* find executable task */
  145.   {
  146.     xtskct = _tschd -> t_xct; /* save task count */
  147.     if ( t_astrm ) t__wtst( tmr_tkct ); /* process wait tasks */
  148.     if ( xtskct == 0 ) t__sch(); /* schedule application tasks if necessary */
  149.     sys_task = _tschd -> t_fxtsk; /* set next task address */
  150.     if ( sys_task != _NULL )  /* test for executable task available */
  151.     {
  152.       _tschd -> t_xct--; /* decrement executing task count */
  153.       _tschd -> t_fxtsk = _tsk -> t_nqtsk; /* delink task */
  154.       if ( _tschd -> t_fxtsk == _NULL )
  155.         _tschd -> t_lxtsk = _NULL;
  156.       else _tschd -> t_fxtsk -> t_pqtsk = _NULL;
  157.       _tsk -> t_type &= ~T_X; /* indicate task not in execution queue */
  158.       ttc = t__xtsk( sys_task ); /* execute application task */
  159.       if ( !sys_task ) continue; /* test for task terminated */
  160.       if ( ttc < 0 ) t__inxq(); /* insert task into execution queue */
  161.       else if ( ttc == 0 ) t__inpq(); /* insert task into priority queue */
  162.       else t__inwq( ttc ); /* insert into wait queue */
  163.     }
  164.   }
  165. }
  166.  
  167. /*
  168. t__wtst                  test waiting tasks
  169. */
  170. t__wtst( tc)
  171. unsigned tc;
  172. /*
  173. The wait queue is traversed.  All tasks with a wait value of tc are executed.
  174. _F is always returned. */
  175. {
  176.   while(_T)              /* traverse wait queue */
  177.   {
  178.     sys_task = _tschd -> t_fwtsk; /* set current task pointer */
  179.     if ( !sys_task ) break; /* test for no waiting tasks */
  180.     _tsk -> t_type &= ~T_W; /* remove task from wait queue */
  181.     _tsk -> t_type |= T_X; /* indicate task in execution queue */
  182.     if ( _tsk -> t_wttk > tc ) break; /* test for effective end of list */
  183.     --_tschd -> t_wct;   /* decrement waiting task  count */
  184.     _tschd -> t_fwtsk = _tsk -> t_nqtsk; /* delink from wait queue */
  185.     if ( _tsk -> t_nqtsk == _NULL )
  186.       _tschd -> t_lwtsk = _NULL;
  187.     else _tsk -> t_nqtsk -> t_pqtsk = _NULL;
  188.     _tsk -> t_pqtsk = _NULL; /* insert at top of execution queue */
  189.     _tsk -> t_nqtsk = _tschd -> t_fxtsk;
  190.     _tschd -> t_fxtsk = sys_task;
  191.     ++_tschd -> t_xct;   /* increment executable task count */
  192.     if ( _tschd -> t_lxtsk == _NULL )
  193.       _tschd -> t_lxtsk = sys_task;
  194.     else _tsk -> t_nqtsk -> t_pqtsk = sys_task;
  195.   }
  196.   return _F;             /* return */
  197. }
  198.  
  199. /*
  200. t__sch                   schedule task
  201. */
  202. t__sch()
  203. /*
  204. This function searches the priority queues and links tasks ready for execution
  205. into the execution queue. The return is always _F. */
  206. {
  207.   struct t_scls **a;     /* priority queue pointer array pointer */
  208.   struct t_scls *q;      /* priority queue pointer */
  209.   int i,j;               /* iteration variables */
  210.   a = _tschd -> t_sclsp; /* set pointer array address */
  211. /*  while(_T)              /* nonterminating task */
  212.   { */
  213.     for ( i = 0; i < _tschd -> t_sclsl; ++i ) /* traverse queues */
  214.     { 
  215.       q = a[i];          /* set priority queue pointer */
  216.       for ( j = 0; j++<q -> t_sfrq; ) /* schedule tasks from priority queue */
  217.       { 
  218.         if ( q -> t_fqtsk == _NULL ) break; /* test for queue empty */
  219.         if ( _tschd -> t_lxtsk ) /* link to end of execution queue */
  220.           _tschd -> t_lxtsk -> t_nqtsk = q -> t_fqtsk;
  221.         else _tschd -> t_fxtsk = q -> t_fqtsk;
  222.         q -> t_fqtsk -> t_type &= ~T_P; /* indicate not in priority queue */
  223.         q -> t_fqtsk -> t_pqtsk = _tschd -> t_lxtsk;
  224.         _tschd -> t_lxtsk = q -> t_fqtsk;
  225.         q -> t_fqtsk = q -> t_fqtsk -> t_nqtsk; /* update queue header */
  226.         _tschd -> t_lxtsk -> t_nqtsk = _NULL;
  227.         if ( q -> t_fqtsk == _NULL )
  228.           q -> t_lqtsk = _NULL;
  229.         else q -> t_fqtsk -> t_pqtsk = _NULL;
  230.         q -> t_sct --;   /* decrement queue count */
  231.         ++ _tschd -> t_xct; /* increment execution queue length */
  232.         _tschd -> t_lxtsk -> t_type |= T_X; /* ind. task in execution queue */
  233.       }
  234.     }
  235. /*    t_rels();            /* return to bottom of execution queue */
  236.   }*/
  237.   return _F;             /* return */
  238. }
  239.  
  240. /*
  241. t__inxq                  insert task into execution queue
  242. */
  243. t__inxq()
  244. /*
  245. The current task is inserted into the execution queue. _F is always returned.
  246. */
  247. {
  248.   _tsk -> t_wttk = 0;    /* indicate not waiting for system tick */
  249.   if ( _tschd -> t_lxtsk == _NULL ) /* test for execution queue empty */
  250.   {
  251.     _tschd -> t_fxtsk = sys_task; /* insert in empty queue */
  252.     _tsk -> t_pqtsk = _NULL;
  253.   }
  254.   else                   /* execution queue not empty */
  255.   { 
  256.     _tschd -> t_lxtsk -> t_nqtsk = sys_task; /* insert at end of queue */
  257.     _tsk -> t_pqtsk = _tschd -> t_lxtsk;
  258.   }
  259.   _tsk -> t_nqtsk = _NULL; /* new task at end of list */
  260.   _tschd -> t_lxtsk = sys_task;
  261.   _tschd -> t_xct++;     /* increment executable task count */
  262.   _tschd -> t_lxtsk -> t_type |= T_X; /* indicate task in execution queue */
  263.   return _F;             /* return */
  264. }
  265.  
  266. /*
  267. t__secw                  process secondary wait queue
  268. */
  269. t__secw()
  270. /*
  271. This program executes every 64K system ticks. It moves the secondary
  272. wait queue to the primary wait queue and changes the type of the waiting
  273. tasks. */
  274. {
  275.   struct t_task *tsk;    /* task control table pointer */
  276.   char swtflg;           /* system state flag */
  277.   while(_T)              /* nonterminating task */
  278.   { 
  279.     t__syntr( &swtflg ); /* enter system state */
  280.     for ( tsk = _tschd -> t_fwtsk; tsk; tsk = tsk -> t_nqtsk ) /* traverse */
  281.     {
  282.       tsk -> t_type &= ~T_SW;
  283.       tsk -> t_type |= T_W; /* change task type */
  284.     }
  285.     _tschd -> t_wct = _tschd -> t_swct; /* append secondary wait queue */
  286.     _tschd -> t_fwtsk = _tschd -> t_fswtsk;
  287.     _tschd -> t_lwtsk = _tschd -> t_lswtsk;
  288.     _tschd -> t_fswtsk = _tschd -> t_lswtsk = _NULL; /* empty sec. queue */
  289.     _tschd -> t_swct = 0;
  290.     t__inwq( 0xFFFF - tmr_tkct ); /* insert self into wait queue at end */
  291.     sys_task = _NULL;    /* remove task from kernel control */
  292.     t_term();            /* suspend execution */
  293.   }
  294. }
  295.  
  296. /*
  297. t__inwq                  insert task into wait queue
  298. */
  299. t__inwq(tc)
  300. unsigned tc;
  301. /*
  302. The  current task is inserted into the wait queue.  tc is the number of system
  303. ticks that the task is to wait. _F is always returned. */
  304. {
  305.   extern unsigned tmr_tkct; /* tick clock */
  306.   unsigned crtk;         /* current tick */
  307.   crtk = tmr_tkct;       /* set current system tick */
  308.   _tsk -> t_wttk = tc + crtk; /* compute reactivation time */
  309.   if ( _tsk -> t_wttk >= crtk ) /* test for task in wait queue */
  310.   { t__inwt( &_tschd -> t_wct ); /* insert in wait queue */
  311.     _tsk -> t_type |= T_W;
  312.   }else                  /* task in secondary wait queue */
  313.   { t__inwt( &_tschd -> t_swct ); /* insert in secondary wait queue */
  314.     _tsk -> t_type |= T_SW;
  315.   }return _F;            /* indicate task inserted */
  316. }
  317.  
  318. /*
  319. t__inwt                  insert into wait or secondary wait queue
  320. */
  321. struct t_wtq
  322. {
  323.   int wct;               /* wait queue length */
  324.   struct t_task *frs,*lst; /* queue header */
  325. };
  326. t__inwt( w )
  327. struct t_wtq *w;
  328. /*
  329. The t_wtq structure is implicitly contained in the scheduling control table
  330. (t_schd structure).  The current task is inserted into the queue. _F is always
  331. returned. */
  332. {
  333.   struct t_task *p;      /* task pointer */
  334.   unsigned tc;           /* reactivation time */
  335.   tc = _tsk -> t_wttk;   /* set reactivation time */
  336.   ++w -> wct;            /* increment queue length */
  337.   for ( p = w -> frs; p; p = p -> t_nqtsk ) /* traverse queue */
  338.   {
  339.     if ( tc < p -> t_wttk ) /* test for task earlier */
  340.     {
  341.       _tsk -> t_nqtsk = p; /* insert within queue */
  342.       _tsk -> t_pqtsk = p -> t_pqtsk;
  343.       p -> t_pqtsk = sys_task;
  344.       if ( ( p = _tsk -> t_pqtsk ) ) p -> t_nqtsk = sys_task;
  345.       else w -> frs = sys_task;
  346.       return _F;         /* indicate task inserted */
  347.     }
  348.   }
  349.   if ( ( p = w -> lst ) ) /* test for wait queue not empty */
  350.   {
  351.     p -> t_nqtsk = w -> lst = sys_task; /* insert at end of queue */
  352.     _tsk -> t_pqtsk = p;
  353.     _tsk -> t_nqtsk = _NULL;
  354.   }
  355.   else                   /* wait queue empty */
  356.   {
  357.     w -> frs = w -> lst = sys_task; /* initialize wait queue */
  358.     _tsk -> t_nqtsk = _tsk -> t_pqtsk = _NULL;
  359.   }
  360.   return _F;             /* indicate task inserted */
  361. }
  362.  
  363. /*
  364. t__inpq                  insert into priority queue
  365. */
  366. t__inpq()
  367. /*
  368. The current task is inserted into its priority queue. _F is always returned.
  369. */
  370. { 
  371.   struct t_scls *q;      /* priority queue pointer */
  372.   _tsk -> t_wttk = 0;    /* indicate not waiting for tick */
  373.   q = _tschd -> t_sclsp[ _tsk -> t_cls ]; /* set priority queue address */
  374.   _tsk -> t_pqtsk = q -> t_lqtsk; /* link task into priority queue */
  375.   _tsk -> t_nqtsk = _NULL;
  376.   if ( q -> t_lqtsk == _NULL ) q -> t_fqtsk = sys_task;
  377.   else q -> t_lqtsk -> t_nqtsk = sys_task;
  378.   q -> t_lqtsk = sys_task;
  379.   ++q -> t_sct;          /* increment queue length */
  380.   _tsk -> t_type |= T_P; /* indicate task in priority queue */
  381.   return _F;             /* return */
  382. }
  383.  
  384. /*
  385. t__xtsk                  execute task
  386. */
  387. t__xtsk( t )
  388. struct t_task *t;
  389. /*
  390. Task t is executed. The returned value is the termination code. 
  391. */
  392. {
  393.   extern unsigned t_mnxtm; /* minimum execution time */
  394.   extern unsigned t_syxtm[]; /* system pseudo time accumulator */
  395.   extern logical t_astrm; /* application termination flag */
  396.   int ttc;               /* return value storage */
  397.   unsigned atm;          /* accumulated time */
  398.   unsigned rtm;          /* reference time */
  399.   int xtm;               /* execution time */
  400.   atm = 0;               /* initialize accumulated execution time */
  401.   while(_T)              /* execute task */
  402.   { 
  403.     rtm = t -> t_xtm0;   /* set reference time */
  404.     t_rtmark( &t -> t_xtm0 ); /* accumulate pseudo time */
  405.     ttc = t__dspap( t -> t_ps.sys_ss, t -> t_ps.sys_sp ); /* execute task */
  406.     t -> t_ps.sys_ss = t__crtss; /* store ss */
  407.     t -> t_ps.sys_sp = t__crtsp; /* store sp */
  408.     t_rtmark( &t_syxtm ); /* accumulate pseudo time */
  409.     if ( ( ttc != 0 ) || !t_astrm ) break; /* test for not tick termination */
  410.     xtm = t -> t_xtm0 - rtm; /* compute execution time */
  411.     if ( xtm < rtm ) xtm = -xtm;
  412.     atm += xtm;          /* accumulate execution time */
  413.     if ( atm >= t_mnxtm ) break; /* test for minimum time satisfied */
  414.   }
  415.   return ttc;            /* return */
  416. }
  417. /*
  418. t__init                  initialize task system
  419. */
  420. t__init()
  421. /*
  422. This function initializes the task system. _F is the normal return. _E is
  423. returned if the system cannot be initialized. */ 
  424. { 
  425. #define WSTK 252         /* t_wqupd stack size */
  426.   extern struct sys_parm sys_stat; /* initial processor status */
  427.   extern struct t_task *t_wqupd; /* secondary wait queue update task */
  428.   extern selector sys_dgrp; /* data segment selector storage */
  429.   extern char *sys_ssbs; /* system stack pointer */
  430.   extern unsigned sys_sssz; /* system stack length */
  431.   extern char tmr_ilck;  /* tick service interlock */
  432.   int t__secw();         /* wait queue update function */
  433.   struct t_scls *cls;    /* priority queue pointer */
  434.   struct t_scls **ary;   /* priority queue pointer array pointer */
  435.   int i;                 /* iteration variable */
  436.   char *s;               /* pointer */
  437.   tmr__int();            /* initialize system tick clock */
  438.   sys_task = sys_ssbs + sys_sssz; /* set main task control table pointer */
  439.   _tsk -> t_xtm0 =       /* initialize execution time */
  440.   _tsk -> t_xtm1 = 
  441.   _tsk -> t_xtm2 = 0;
  442.   if( ( sys_tsch = mm_aloc( sizeof( struct t_schd ) ) ) == _NULL )goto err1;
  443.   if( ( ary = mm_aloc( T_SCLS*( sizeof( struct t_scls )+2 ) ) )
  444.      == _NULL )goto err2;
  445.   _tsk -> t_pqtsk =      /* NULL linkage */
  446.   _tsk -> t_nqtsk =
  447.   _tsk -> t_ratsk =
  448.   _tsk -> t_pstsk =
  449.   _tsk -> t_nstsk =
  450.   _tsk -> t_fdtsk =
  451.   _tsk -> t_ldtsk = _NULL;
  452.   _tsk -> t_cls = 0;     /* set priority class 0 */
  453.   _tsk -> t_wttk = 0;    /* indicate not waiting */
  454.   for( i = 0, s = &_tsk -> t_ps;
  455.     i++<sizeof( struct sys_parm ); )*s = 0; /* clear t_ps */
  456.   _tsk -> t_ps.sys_cs = sys_stat.sys_cs; /* set selectors */
  457.   _tsk -> t_ps.sys_ds =
  458.   _tsk -> t_ps.sys_es =
  459.   _tsk -> t_ps.sys_ss = sys_dgrp;
  460.   _tsk -> t_axstk = _NULL; /* NULL execution stack pointer */
  461.   _tschd -> t_xct = 1;   /* set execution task count */
  462.   _tschd -> t_fxtsk =    /* set execution queue */
  463.   _tschd -> t_lxtsk = sys_task;
  464.   _tschd -> t_wct = 0;   /* indicate idle wait queue */
  465.   _tschd -> t_fwtsk =    /* set wait queue */
  466.   _tschd -> t_lwtsk = _NULL;
  467.   _tschd -> t_swct = 0;  /* indicate empty secondary wait queue */
  468.   _tschd -> t_fswtsk =   /* NULL secondary wait queue */
  469.   _tschd -> t_lswtsk = _NULL;
  470.   _tschd -> t_sclsl = T_SCLS; /* set priority queue count */
  471.   _tschd -> t_sclsp = ary; /* set priority queue pointer array address */
  472.   cls = &ary[ T_SCLS ];  /* set first t_scls pointer */
  473.   for( i = 0; i<T_SCLS; ++i, ++cls ) /* initialize priority queues */
  474.   {
  475.     ary[i] = cls;        /* set priority queue pointer */
  476.     cls -> t_sfrq = 1;   /* set default frequency */
  477.     cls -> t_sct = 0;    /* indicate empty queue */
  478.     cls -> t_fqtsk =     /* NULL queue linkage */
  479.     cls -> t_lqtsk = _NULL;
  480.   }
  481.   t_wqupd =              /* create task to update wait queue */
  482.     t_crt( t__secw, 0, 0, WSTK, 0, 0, 0 );
  483.   if( t_wqupd == _NULL )goto err3;
  484.   t_wqupd -> t_wttk = 0xFFFF; /* update wait queue at wraparound time */
  485.   t__dspsy();            /* dispatch system */
  486.   tmr_ilck = 0x00;       /* enable tick service */
  487.   return _F;             /* indicate task system initialized */
  488. err3: mm_free( ary );    /* error nest */
  489. err2: mm_free( sys_tsch );
  490. err1: return _E;
  491. }
  492.  
  493. /*
  494. t__term
  495. */
  496. t__term()
  497. /*
  498. The task system is terminated. All tasks and storage allocated by t__init are
  499. released. The return is always _F. */
  500. {
  501.   extern char *sys_ssbs; /* system stack base */
  502.   extern unsigned sys_sssz; /* system stack size */
  503.   struct t_task *t;      /* t_task pointer */
  504.   char trmflg;           /* system state flag storage */
  505.   tmr__rst();            /* reset system tick clock */
  506.   t__syntr( &trmflg );   /* enter system state */
  507.   sys_task = sys_ssbs + sys_sssz; /* set original task address */
  508.   while( ( t = _tsk -> t_fdtsk ) ) /* delete all created tasks */
  509.     t_del( t, _F );
  510.   mm_free( _tschd -> t_sclsp );
  511.   mm_free( sys_tsch );
  512.   return _F;             /* normal return */
  513. }
  514.  
  515. /*
  516. t_crt                    create task
  517. */
  518. t_crt( xadr, pcnt, padr, ssiz, dsiz, sadr, prty )
  519. pointer *xadr;
  520. unsigned pcnt;
  521. unsigned *padr;
  522. unsigned ssiz, dsiz;
  523. pointer *sadr;
  524. unsigned prty;
  525. /*
  526. A  new task is created with execution priority prty.  Execution will begin  at 
  527. xadr.  pcnt parameters will be passed (on the new task stack).  The parameters 
  528. are  in  an array addressed by padr.  The new task will have a stack  of  ssiz 
  529. bytes  and a dynamic memory area of dsiz bytes.  dsiz may be zero to  indicate 
  530. that no dynamic memory is required.  sadr will recieve a termination code when 
  531. the  task  terminates. If sadr is _NULL, an abreviated task is created. _F  is 
  532. returned if insufficient memory  is  available.  Otherwise the address of the 
  533. t_ftask table is returned. */
  534. {
  535.   extern int t__halt();  /* return address */
  536.   struct t_task *tsk;    /* task control table pointer (t_task) */
  537.   struct t_scls *pq;     /* priority queue pointer */
  538.   struct t_xstck *sp;    /* execution stack pointer */
  539.   pointer *ss;           /* stack start */
  540.   unsigned *pr;          /* parameter pointer */
  541.   unsigned ln;           /* task control table length */
  542.   int i;                 /* iteration variable */
  543.   char *s;               /* pointer */
  544.   char *sptr;            /* execution stack pointer */
  545.   logical crtflg;        /* system state flag storage */
  546.   t__syntr( &crtflg );   /* enter system state */
  547.   ln = sizeof( struct t_task );  /* allocate task control table */
  548.   if( ( tsk = mm_aloc( ln ) ) == _NULL ) goto err1;
  549.   ssiz += sizeof( struct t_xstck ); /* allocate stack */
  550.   if( ( ss = tsk -> t_axstk = mm_aloc( ssiz ) ) == _NULL )goto err2;
  551.   tsk -> t_type = T_ATASK; /* indicate abreviated task control table */
  552.   tsk -> t_wttk = 0;     /* indicate not waiting */
  553.   tsk -> t_ratsk = sys_task; /* task family linkage */
  554.   tsk -> t_pstsk = _tsk -> t_ldtsk;
  555.   tsk -> t_nstsk =
  556.   tsk -> t_fdtsk =
  557.   tsk -> t_ldtsk = _NULL;
  558.   _tsk -> t_ldtsk = tsk;
  559.   if( tsk -> t_pstsk == _NULL )_tsk -> t_fdtsk = tsk;
  560.   else tsk -> t_pstsk -> t_nstsk = tsk;
  561.   if( prty > _tschd -> t_sclsl ) /* adjust priority */
  562.     prty = _tschd -> t_sclsl-1;
  563.   tsk -> t_cls = prty;   /* set priority */
  564.   pq = _tschd -> t_sclsp[ prty ]; /* set scheduling array pointer */
  565.   ++pq -> t_sct;         /* scheduling linkage */
  566.   tsk -> t_pqtsk = pq -> t_lqtsk;
  567.   tsk -> t_nqtsk = _NULL;
  568.   if( tsk -> t_pqtsk == _NULL )pq -> t_fqtsk = tsk;
  569.   else tsk -> t_pqtsk -> t_nqtsk = tsk;
  570.   pq -> t_lqtsk = tsk;
  571.   tsk -> t_xtm0 =        /* no execution time yet */
  572.   tsk -> t_xtm1 =
  573.   tsk -> t_xtm2 = 0;
  574.   pr = sptr = ss+ssiz-2*pcnt; /* initialize execution stack & t_ps */
  575.   tsk -> t_ps.sys_sp =
  576.   sp = sptr - sizeof( struct t_xstck );
  577.   sp -> t_xbp = ss + ssiz;
  578.   sp -> t_xbase = ss;
  579.   while( pcnt-- )*pr++ = *padr++;
  580.   for( i = 0, s = &tsk -> t_ps; i++ < sizeof( struct sys_parm ); )*s = 0;
  581.   tsk -> t_ps.sys_ds =
  582.   tsk -> t_ps.sys_es =
  583.   tsk -> t_ps.sys_ss =
  584.   sp -> t_xds =
  585.   sp -> t_xes =  _tsk -> t_ps.sys_ds;
  586.   sp -> t_xdi =
  587.   sp -> t_xsi =
  588.   sp -> t_xdx =
  589.   sp -> t_xcx =
  590.   sp -> t_xbx =
  591.   sp -> t_xax = _NULL;
  592.   sp -> t_xip = xadr;
  593.   tsk -> t_ps.sys_cs =
  594.   sp -> t_xcs =
  595.   _tsk -> t_ps.sys_cs;
  596.   tsk -> t_ps.sys_pf =
  597.   sp -> t_xpf = SYS_IF;
  598.   tsk -> t_ps.sys_ip =
  599.   sp -> t_retip = &t__halt;
  600.   t__syxit( &crtflg );   /* exit system state */
  601.   return tsk;            /* return */
  602. err3: mm_free( tsk -> t_ps.sys_ss );
  603. err2: mm_free( tsk );
  604. err1: t__syxit( &crtflg );
  605.   return _NULL;
  606. }
  607.  
  608. /*
  609. t__halt                  terminate task
  610. */
  611. t__halt()
  612. /*
  613. If  a subtask returns into its orginal stack,  control will pass  to  t__halt. 
  614. This  function  deletes the subtask and then clears the sys_task pointer  just 
  615. before returning on the system stack (to reenter the security kernel). */
  616. {
  617.   logical haltflg;       /* system state flag storage */
  618.   t__syntr( &haltflg );  /* enter system state */
  619.   t_rtmark( &_tsk -> t_ratsk -> t_xtm0 ); /* accumulate pseudo time */
  620.   t_del( sys_task, _F ); /* delete current task */
  621.   sys_task = _NULL;      /* indicate task terminated */
  622.   while(_T)t_term();     /* return to security kernel */
  623. }
  624.  
  625. /*
  626. t_del                    delete task
  627. */
  628. t_del( tsk, st )
  629. struct t_task *tsk;
  630. int st;
  631. /*
  632. Task tsk is killed. st is the status returned to the calling program.
  633. */
  634. {
  635. #define tskf ( ( struct t_ftask * )tsk ) /** (t_ftask) */
  636.   struct t_task *t;      /* task control table pointer */
  637.   logical delflg;        /* system state flag storage */
  638.   t__syntr( &delflg );   /* enter system state */
  639.   while( ( t = tsk -> t_fdtsk ) )t_del( t, st ); /* delete subtasks first */
  640.   if( tsk -> t_pstsk )   /* family linkage */
  641.     tsk -> t_pstsk -> t_nstsk = tsk -> t_nstsk;
  642.   else tsk -> t_ratsk -> t_ldtsk = tsk -> t_nstsk;
  643.   if( tsk -> t_nstsk )
  644.     tsk -> t_nstsk -> t_pstsk = tsk -> t_pstsk;
  645.   else tsk -> t_ratsk -> t_fdtsk = tsk -> t_pstsk;
  646.   if( tsk -> t_pqtsk )   /* queue linkage */
  647.     tsk -> t_pqtsk -> t_nqtsk = tsk -> t_nqtsk;
  648.   else if( ( tsk -> t_type&T_P )
  649.        && ( _tschd -> t_sclsp[ tsk -> t_cls ] -> t_fqtsk == tsk ) )
  650.          _tschd -> t_sclsp[ tsk -> t_cls ] -> t_fqtsk = tsk -> t_nqtsk;
  651.   else if( ( tsk -> t_type&T_W ) && ( _tschd -> t_fwtsk == tsk ) )
  652.     _tschd -> t_fwtsk = tsk -> t_nqtsk;
  653.   else if( ( tsk -> t_type&T_SW ) && ( _tschd -> t_fswtsk == tsk ) )
  654.     _tschd -> t_fswtsk = tsk -> t_nqtsk;
  655.   else if( ( tsk -> t_type&T_X ) && ( _tschd -> t_fxtsk == tsk ) )
  656.     _tschd -> t_fxtsk = tsk -> t_nqtsk;
  657.   if( tsk -> t_nqtsk )tsk -> t_nqtsk -> t_pqtsk = tsk -> t_pqtsk;
  658.   else if( ( tsk -> t_type&T_P )
  659.        && ( _tschd -> t_sclsp[ tsk -> t_cls ] -> t_lqtsk == tsk ) )
  660.          _tschd -> t_sclsp[tsk -> t_cls] -> t_lqtsk = tsk -> t_pqtsk;
  661.   else if( ( tsk -> t_type&T_W ) && ( _tschd -> t_fwtsk == tsk ) )
  662.     _tschd -> t_lwtsk = tsk -> t_pqtsk;
  663.   else if( ( tsk -> t_type&T_SW ) && ( _tschd -> t_fswtsk == tsk ) )
  664.     _tschd -> t_lswtsk = tsk -> t_pqtsk;
  665.   else if( ( tsk -> t_type&T_X ) && ( _tschd -> t_fxtsk == tsk ) )
  666.    _tschd -> t_lxtsk = tsk -> t_pqtsk;
  667.   t = sys_task;          /* save current t_task pointer */
  668.   sys_task = tsk -> t_ratsk; /* set ancestor task */
  669.   mm_free( tsk -> t_ps.sys_ss ); /* free stack */
  670.   mm_free( tsk );        /* free t_task table */
  671.   sys_task = t;          /* restore current task pointer */
  672.   t__syxit( &delflg );   /* exit system state */
  673.   return _F;             /* return */
  674. }
  675.  
  676. /*
  677. mm_aloc                  memory allocation
  678. */
  679. mm_aloc(ln)
  680. unsigned ln;
  681. /*
  682. ln bytes are allocated from the heap. The address of the first byte is
  683. returned. If there is not enough available memory to satisfy the request,
  684. _NULL is returned. */
  685. {
  686.   return malloc(ln);     /* allocate storage */
  687. }
  688.  
  689. /*
  690. mm_free                  memory deallocation
  691. */
  692. mm_free(st)
  693. char *st;
  694. /*
  695. st is the address returned by a previous call to function mm_free. The storage
  696. previously allocated is made available for future use. The normal return is
  697. _F. _E is returned if st does not point to an area previously allocated by
  698. mm_aloc. */
  699. {
  700.   return free(st);       /* deallocate storage */
  701. } 
  702.  
  703. /*
  704. main                     test program
  705. */
  706. main()
  707. /*
  708. This function serves to test the task scheduler. Two tasks are created, each
  709. of which increments a variable. The original task continually displays the
  710. counts, as well as its own iteration number. Depressing any key will cause a
  711. return to MS-DOS. */
  712. {
  713.   int ctr1, ctr2, ctr3;  /* counters */
  714.   int count();           /* counting subroutine */
  715.   int param[ 2 ];        /* parameter array */
  716.   printf("tasktest (C) 1986 Ken Berry- All Rights Reserved\n");
  717.   printf("Tele task scheduler: 1986 September 2 version (DDJ mod)\n\n");
  718.   t__init();             /* initialize task scheduler */
  719.   ctr1 = ctr2 = ctr3 = 0; /* initialize counters */
  720.   param[ 0 ] = &ctr1;    /* create first task */
  721.   param[ 1 ] = 1;
  722.   t_crt( count, 2, ¶m, 256, 0, 0, 0);
  723.   param[ 0 ] = &ctr2;    /* create second task */
  724.   param[ 1 ] = 2;
  725.   t_crt( count, 2, ¶m, 256, 0, 0, 0);
  726.   while( !kbhit() )      /* loop until key depressed */
  727.   {
  728.     ++ctr3;              /* increment main loop count */
  729.     printf("main = %d, task 1 = %d, task 2 = %d\n", ctr3, ctr1, ctr2 );
  730.   }
  731.   getch();               /* discard termination character */
  732.   t__term();             /* terminate task scheduler */
  733.   return _F;             /* return to MS÷DOS */
  734. }
  735.  
  736. count(ctr,inc)
  737. int *ctr,inc;
  738. {
  739.   while(_T)              /* infinite loop */
  740.   {
  741.     *ctr += inc;         /* update counter */
  742.   }
  743. }
  744.  
  745.  
  746.  
  747. Listing 2-     System Definitions
  748. (C) Copyright 1986 Ken Berry.
  749. All rights reserved.
  750. Copies may be made for non-commercial, private use only.
  751.  
  752.  
  753. sys_parm  struc          ;; register storage block
  754. rax       dw ?           ;; ax (general register A)
  755. rbx       dw ?           ;; bx (general register B)
  756. rcx       dw ?           ;; cx (general register C)
  757. rdx       dw ?           ;; dx (general register D)
  758. rbp       dw ?           ;; bp (base pointer)
  759. rsi       dw ?           ;; si (source index)
  760. rdi       dw ?           ;; di (destination index)
  761. rsp       dw ?           ;; sp (stack pointer)
  762. rcs       dw ?           ;; cs (code segment)
  763. rds       dw ?           ;; ds (data segment)
  764. rss       dw ?           ;; ss (stack segment)
  765. res       dw ?           ;; es (extra segment)
  766. rpf       dw ?           ;; pf (processor flags)
  767. rsw       dw ?           ;; sw (status word)
  768. rip       dw ?           ;; ip (instruction pointer)
  769. rres      dw ?           ;; unused
  770. sys_parm  ends
  771.  
  772. t_task    struc          ;; task control table
  773. t_type    db ?           ;; task type
  774. t_wttk    dw ?           ;; wait tick count
  775. t_cls     dw ?           ;; priority queue index
  776. t_pqtsk   dw ?           ;; prior t_task pointer
  777. t_nqtsk   dw ?           ;; next t_task pointer
  778. t_ratsk   dw ?           ;; ancestor t_task pointer
  779. t_pstsk   dw ?           ;; prior sibling t_task pointer
  780. t_nstsk   dw ?           ;; next sibling t_task pointer
  781. t_fdtsk   dw ?           ;; first desendant t_task pointer
  782. t_ldtsk   dw ?           ;; last desendant t_task pointer
  783. t_ps      db type sys_parm dup (?) ;; processor status
  784. t_xtm0    dw ?           ;; *  execution time accumulator
  785. t_xtm1    dw ?           ;; *
  786. t_xtm2    dw ?           ;; *
  787. t_axstk   dw ?           ;; application stack pointer
  788. t_task    ends
  789.  
  790. T_ATSK    equ 01h        ;; abreviated task
  791. T_X       equ 80h        ;; execute wueue
  792. T_W       equ 40h        ;; wait queue
  793. T_P       equ 20h        ;; priority queue
  794. t_SW      equ 10h        ;; secondary wait queue
  795.  
  796. t_scls    struc          ;; scheduling class queue
  797. t_sfrq    dw ?           ;; scheduling frequency
  798. t_sct     dw ?           ;; queue length
  799. t_fqtsk   dw ?           ;; first task in queue
  800. t_lqtsk   dw ?           ;; last task in queue
  801. t_scls    ends
  802.  
  803. t_schd    struc          ;; scheduling control table
  804. t_xct     dw ?           ;; execution queue length
  805. t_fxtsk   dw ?           ;; first task in execution queue
  806. t_lxtsk   dw ?           ;; last task in execution queue
  807. t_wct     dw ?           ;; wait queue length
  808. t_fwtsk   dw ?           ;; first task in wait queue
  809. t_lwtsk   dw ?           ;; last task in wait queue
  810. t_swct    dw ?           ;; secondary wait queue length
  811. t_fswtsk  dw ?           ;; first task in secondary wait queue
  812. t_lswtsk  dw ?           ;; last task in secondary wait queue
  813. t_sclsl   dw ?           ;; scheduling class index limit
  814. t_sclsp   dw ?           ;; scheduling class array pointer
  815. t_schd    ends
  816.  
  817. t_calln   struc          ;; near function call
  818. t_nbp     dw ?           ;; base pointer storage
  819. t_nret    dw ?           ;; return address
  820. t_np0     dw ?           ;; parameter 0
  821. t_np1     dw ?           ;; parameter 1
  822. t_np2     dw ?           ;; parameter 2
  823. t_np3     dw ?           ;; parameter 3
  824. t_np4     dw ?           ;; parameter 4
  825. t_np5     dw ?           ;; parameter 5
  826. t_np6     dw ?           ;; parameter 6
  827. t_np7     dw ?           ;; parameter 7
  828. t_calln   ends
  829.  
  830. t_xtsk    struc          ;; execution stack
  831. t_xbase   dw ?           ;; _base (for stack overflow detection)
  832. t_xes     dw ?           ;; es
  833. t_xbp     dw ?           ;; bp
  834. t_xdi     dw ?           ;; di
  835. t_xsi     dw ?           ;; si
  836. t_xdx     dw ?           ;; dx
  837. t_xcx     dw ?           ;; cx
  838. t_xbx     dw ?           ;; bx
  839. t_xax     dw ?           ;; ax
  840. t_xds     dw ?           ;; ds
  841. t_xip     dw ?           ;; ip
  842. t_xcs     dw ?           ;; cs
  843. t_xpf     dw ?           ;; pf
  844. t_retip   dw ?           ;; return ip
  845. t_xtsk    ends
  846.  
  847. retn      macro s        ;; near return 
  848.   ifnb <s>
  849.           db 0C2h        ;; pop ip & adjust sp
  850.           db high s      ;; *  adjustment value
  851.           db low s       ;; *
  852.   else
  853.           db 0C3h        ;; pop ip only
  854.   endif
  855.           endm
  856.  
  857. retf      macro s        ;; far return
  858.   ifnb <s>
  859.           db 0CCh        ;; pop ip, cs & adjust sp
  860.           db high s      ;; *  adjustment value
  861.           db low s       ;; *
  862.   else
  863.           db 0CBh        ;; pop ip, cs only
  864.   endif
  865.           endm
  866.  
  867. ilck      macro reg,flag
  868.           xchg reg,flag  ;; capture token
  869.           endm
  870.  
  871. iowait    macro
  872.           nop            ;; I/O delay
  873.           endm
  874.  
  875. sys_entr  macro flag     ;; enter system function
  876.   ifndef sys_ilck
  877.           extrn sys_ilck:byte
  878.   endif
  879.           mov al,0FFh    ;; ** system task interlock
  880.           ilck al,sys_ilck ;; **
  881.           mov flag,al    ;; save asynchronous status
  882.           endm
  883.  
  884. sys_exit  macro flag     ;; exit from system function
  885.           local exit1,exit2
  886.   ifndef sys_ilck
  887.           extrn sys_ilck:byte
  888.   endif
  889.   ifndef t_astrm
  890.           extrn t_astrm:byte
  891.   endif
  892.   ifndef t_term
  893.           extrn t_term:near
  894.   endif
  895.           test byte ptr t_astrm,0FFh ;; *  test for application terminated
  896.           jnz exit1      ;; *
  897.           mov byte ptr sys_ilck,0 ;; exit system state
  898.           jmp short exit2 ;; continue application task
  899. exit1:    test flag,0FFH ;; ** test for more stacked system tasks
  900.           jnz exit2      ;; **
  901.           call t_term    ;; terminate application task
  902. exit2:                   ;; macro exit
  903.           endm
  904.  
  905. sys_sync  macro flag     ;; synchronize system resource
  906.   ifndef t_sync
  907.           extrn t_sync:near
  908.   endif
  909.           lea bx,flag    ;; set flag offset
  910.           call t_sync    ;; suspend task until token obtained
  911.           endm
  912.  
  913. sys_sstk  macro          ;; conditionally establish system stack
  914.           local sstk1
  915.   ifndef t__sstk
  916.           extrn t__sstk:near
  917.   endif
  918.           or al,al       ;; *  test for system task interrupted
  919.           jnz sstk1      ;; *
  920.           call t__sstk   ;; establish system stack
  921. sstk1:    push ds        ;; ** set es = ds
  922.           pop es         ;; **
  923.           endm
  924.  
  925. sys_sctx  macro          ;; save processor context
  926.           push bx        ;; protect bx
  927.           push cx        ;; protect cx
  928.           push dx        ;; protect dx
  929.           push si        ;; protect si
  930.           push di        ;; protect di
  931.           push bp        ;; protect bp
  932.           push es        ;; protect es
  933.           cld            ;; clear direction flag
  934.           sys_sstk       ;; conditionally establish system stack
  935.           endm
  936.  
  937. sys__rctx macro          ;; restore processor context (except ds)
  938.           pop es         ;; restore es
  939.           pop bp         ;; restore bp
  940.           pop di         ;; restore di
  941.           pop si         ;; restore si
  942.           pop dx         ;; restore dx
  943.           pop cx         ;; restore cx
  944.           pop bx         ;; restore bx
  945.           pop ax         ;; restore ax
  946.           endm
  947.  
  948. sys_rctx  macro          ;; restore processor context
  949.           sys__rctx      ;; restore context (except ds)
  950.           pop ds         ;; restore ds
  951.           endm
  952.  
  953. sys_ient  macro flag
  954.           push ds        ;; protect ds
  955.           push ax        ;; protect ax
  956.           mov ax,dgroup  ;; *  establish data addressability
  957.           mov ds,ax      ;; *
  958.           sys_entr flag  ;; enter system state
  959.           sti            ;; interrupts on
  960.           sys_sctx       ;; save processor context
  961.           endm
  962.  
  963. sys_iret  macro flag
  964.           local iret1
  965.   ifndef t_astrm
  966.           extrn t_astrm:byte
  967.   endif
  968.           cli            ;; interrupts off
  969.           test byte ptr t_astrm,0FFh ;; *  test for application not terminated
  970.           jz iret1       ;; *
  971.           test flag,0FFh ;; ** test for system state interrupted
  972.           jnz iret1      ;; **
  973.           sti            ;; interrupts on
  974.           retn           ;; return to task management
  975. iret1:    sys_rctx       ;; restore processor context
  976.           iret           ;; resume interrupted task
  977.           endm
  978.  
  979. dseg      macro
  980. dgroup    group data
  981. data      segment word public 'data'
  982.           assume ds:dgroup,es:dgroup,ss:dgroup
  983.           endm
  984.  
  985. endds     macro
  986. data      ends
  987.           endm
  988.  
  989. pseg      macro
  990. pgroup    group prog
  991. prog      segment byte public 'prog'
  992.           assume cs:pgroup
  993.           endm
  994.  
  995. endps     macro
  996. prog      ends
  997.           endm
  998.  
  999.  
  1000.  
  1001. Listing 3      Scheduling Algorithm (Assembly Subroutines)
  1002. (C) Copyright 1986 Ken Berry.
  1003. All rights reserved.
  1004. Copies may be made for non-commercial, private use only.
  1005.  
  1006.  
  1007.           include tele.mac ; system definitions (listing 2)
  1008.  
  1009.           extrn t_astrm:byte ; application task termination flag
  1010.           extrn t_rtmark:near ; update pseudo time accumulator
  1011.           extrn t__krnl:near ; security kernel
  1012.  
  1013.           public sys_task ; current task pointer
  1014.           public sys_tsch ; task scheduling table pointer
  1015.           public sys_ilck ; system task interlock
  1016.           public sys_asbs ; application stack base
  1017.           public sys_dgrp ; data segment storage
  1018.           public sys_ssbs ; system stack base
  1019.           public sys_sssz ; system stack size
  1020.           public sys_sstp ; system stack top
  1021.           public sys_stat ; original register block
  1022.           public t_mnxtm ; minimum execution time
  1023.           public t_rels  ; release
  1024.           public t_spnd  ; suspend
  1025.           public t_syxtm ; system pseudo time accumulator
  1026.           public t_term  ; reschedule
  1027.           public t_wait  ; wait
  1028.           public t_wqupd ; wait queue update task pointer
  1029.           public t__crtss ; current task ss storage
  1030.           public t__crtsp ; current task sp storage
  1031.           public t__dspap ; dispatch application
  1032.           public t__dspsy ; dispatch system
  1033.           public t__sstk ; establish system stack
  1034.           public t__syntr ; enter system state
  1035.           public t__syxit ; exit system state
  1036.  
  1037. MINXTM    equ 500        ; minimum execution time
  1038. STKLN     equ 1024       ; system stack size
  1039.  
  1040.           dseg
  1041.  
  1042. tmrdx     dw 0           ; dx storage
  1043. spdss     dw 0           ; ss storage
  1044. spdsp     dw 0           ; sp storage
  1045.  
  1046. t__crtss  dw 0           ; current task ss storage
  1047. t__crtsp  dw 0           ; current task sp storage
  1048.  
  1049. sys_stat  db type sys_parm dup (0) ; original register block
  1050. sys_dgrp  dw 0           ; data segment storage
  1051. sys_task  dw 0           ; current task pointer
  1052. sys_tsch  dw 0           ; task scheduling table pointer
  1053. sys_asbs  dw 0           ; application stack base
  1054. sys_ssbs  dw stkbs       ; system stack base
  1055. sys_sssz  dw STKLN       ; system stack length
  1056. sys_sstp  dw STKLN       ; system stack top
  1057. sys_ilck  db 0FFh        ; system task interlock
  1058.  
  1059. t_wqupd   dw 0           ; wait queue update task pointer
  1060.  
  1061. t_syxtm   dw 3 dup (0)   ; system pseudo time accumulator
  1062.  
  1063. t_mnxtm   dw MINXTM      ; minimum execution time
  1064.  
  1065. stkbs     db STKLN dup (0) ; system stack
  1066.           db type t_task dup (0) ; main task control table
  1067.  
  1068.           endds
  1069.  
  1070.           pseg
  1071.  
  1072. comment ~
  1073.  
  1074. t__dspap(ss,sp)
  1075. selector ss;
  1076. unsigned sp;
  1077.  
  1078. ss  and  sp are placed in the stack registers.  Then the other  registers  are 
  1079. restored from the new stack.  Control passes to the restored task.  The return 
  1080. address  is left at the top of the system stack.  Therefore the restored  task 
  1081. may use the system stack to return to the caller of t__dspap. ax may contain a 
  1082. return code in this case.
  1083. ~
  1084.  
  1085. t__dspap  proc near
  1086.           push bp        ; protect bp
  1087.           mov bp,sp      ; establish parameter addressability
  1088.           mov ax,[bp].t_np0 ; set application stack
  1089.           mov bx,[bp].t_np1
  1090.           mov sys_sstp,sp ; store current top of system stack
  1091.           cli
  1092.           mov ss,ax
  1093.           mov sp,bx
  1094.           mov bp,sp      ; enable interrupts
  1095.           or [bp].t_xpf,0200h
  1096.           pop sys_asbs
  1097.           sti
  1098.           sys__rctx      ; restore context
  1099.           cli            ; interrupts off
  1100.           mov byte ptr sys_ilck,0 ; exit system state
  1101.           mov byte ptr t_astrm,0 ; initialize application interval
  1102.           pop ds         ; restore ds
  1103.           iret           ; execute task
  1104. t__dspap  endp
  1105.  
  1106. comment ~
  1107.  
  1108. t_term()       _F
  1109. t_spnd(tp)     tp
  1110. t_wait(tp)     tp
  1111. unsigned tp;
  1112. t_rels()       _E
  1113.  
  1114. All of these functions are similar.  The processor registers are stored on
  1115. the stack,  which  is  then  adjusted  to  match the pattern for interrupt
  1116. returns. Finally the system stack is established.  The  functions  differ  in
  1117. the  code returned  to  the caller of function t__dspap.  t__dspap restores
  1118. the registers and returns control to the caller of these functions.  The
  1119. returned  value  is shown with the appropriate call above.  tp is only used
  1120. with t_spnd and t_wait.  It is the number of system ticks to  wait  before
  1121. executing  the  task  again.  t_wait functions like t_spnd, except that t_rels
  1122. is invoked immediately.  ~
  1123.  
  1124. t_term    proc near
  1125.           call t__trmap  ; protect registers
  1126.           xor ax,ax      ; return _F
  1127.           ret
  1128. t_term    endp
  1129.  
  1130. t_spnd    proc near
  1131.           mov spdss,ss   ; store stack pointers
  1132.           mov spdsp,sp
  1133.           call t__trmap  ; protect registers
  1134.           mov es,spdss   ; return tick count
  1135.           mov si,spdsp
  1136.           mov ax,word ptr es:[si+2]
  1137.           push ds        ; set es = ds
  1138.           pop es
  1139.           ret            ; return
  1140. t_spnd    endp
  1141.  
  1142. t_wait    proc near
  1143.           push bp        ; protect bp
  1144.           mov bp,sp      ; establish stack addressability
  1145.           mov ax,[bp].t_np0 ; suspend task
  1146.           push ax
  1147.           call t_spnd
  1148.           mov sp,bp      ; unload stack
  1149.           pop bp         ; restore bp
  1150. t_rels    proc near
  1151.           call t__trmap  ; protect registers
  1152.           xor ax,ax      ; return _E
  1153.           dec ax
  1154.           ret
  1155. t_rels    endp
  1156. t_wait    endp
  1157.  
  1158. comment ~
  1159.  
  1160. t__dspsy()
  1161.  
  1162. A call to function t__trmap is made so that after the registers are stored in
  1163. the  application stack (and the system stack is made current),  control passes
  1164. to  function t__krnl,  the system security kernel.  Control will  return  from
  1165. t__dspsy when the calling task is resumed. Nothing is returned.
  1166. ~
  1167.  
  1168. t__dspsy  proc near
  1169.           mov ax,offset pgroup:t__krnl ; branch to system
  1170.           push ax
  1171.           sub sys_sstp,2 ; adjust system stack (for "pop bp" in t__sstk)
  1172.  
  1173. comment ~
  1174.  
  1175. t__trmap()
  1176.  
  1177. The  machine registers are stored on the application stack.  Then the system
  1178. stack is made current.  The return address from the call to t__trmap is put on
  1179. the system stack before returning to it. Nothing is returned.
  1180. ~
  1181.  
  1182. t__trmap  proc near
  1183.           mov byte ptr sys_ilck,0FFh ; force system state
  1184.           mov tmrdx,dx   ; save dx
  1185.           pop dx         ; set return address (from t__trmap)
  1186.           push cs        ; protect cs
  1187.           pushf          ; protect flags
  1188.           push ds        ; protect ds
  1189.           push ax        ; protect ax
  1190.           push bx        ; protect bx
  1191.           push cx        ; protect cx
  1192.           push tmrdx     ; protect dx
  1193.           push si        ; protect si
  1194.           push di        ; protect di
  1195.           push bp        ; protect bp
  1196.           push es        ; protect es
  1197.           push dx        ; restore return address to stack
  1198.           mov bp,sp      ; establish stack addressability
  1199.           mov ax,[bp].t_xip ; adjust stack for interrupt return
  1200.           xchg ax,[bp].t_xpf
  1201.           mov [bp].t_xip,ax
  1202.  
  1203. comment ~
  1204.  
  1205. t__sstk()
  1206.  
  1207. The  current application stack pointers are stored.  Then the system stack is
  1208. established as the current stack.  The return address from the call is placed
  1209. on the system stack before returning into it. Nothing is returned.
  1210. ~
  1211.  
  1212. t__sstk   proc near
  1213.           pop dx         ; unload return address
  1214.           push sys_asbs  ; protect stack protection reference
  1215.           mov bx,ss      ; set application stack registers
  1216.           mov cx,sp
  1217.           mov ax,sys_ssbs ; set system stack
  1218.           cli
  1219.           mov sys_asbs,ax
  1220.           push ds
  1221.           pop ss
  1222.           mov sp,sys_sstp
  1223.           sti
  1224.           pop bp         ; restore bp
  1225.           mov t__crtss,bx ; store current ss
  1226.           mov t__crtsp,cx ; store current bp
  1227.           push dx        ; return to caller
  1228.           ret
  1229. t__sstk   endp
  1230. t__trmap  endp
  1231. t__dspsy  endp
  1232.  
  1233. comment ~
  1234.  
  1235. t_sync(flg)
  1236. char *flg;
  1237.  
  1238. A wait loop will be entered until the required resource is available. This is
  1239. indicated  by flg containing 0x00.  0xFF is stored to prevent any other tasks
  1240. from acquiring the resource. The resource is released by resetting flg to
  1241. 0x00.
  1242. ~
  1243.  
  1244. t_sync    proc near
  1245.           push bp        ; protect bp
  1246.           mov bp,sp      ; establish stack addressability
  1247.           mov bx,[bp].t_np0 ; set pointer to resource flag
  1248.  
  1249. sync1:    mov al,0FFh    ; interlock token
  1250.           ilck al,<byte ptr [bx]>
  1251.           or al,al       ; test for token acquired
  1252.           jz sync2
  1253.           xor ax,ax      ; wait for 1 system tick
  1254.           inc ax
  1255.           push ax
  1256.           call t_spnd
  1257.           mov sp,bp
  1258.           jmp sync1      ; continue
  1259.  
  1260. sync2:    pop bp         ; restore bp
  1261.           call t_rels    ; release task
  1262.           ret            ; return
  1263. t_sync    endp
  1264.  
  1265. comment ~
  1266.  
  1267. t__syntr(flg)
  1268. char *flg;
  1269.  
  1270. This function expands the sys_entr macro for use by c functions.
  1271. ~
  1272.  
  1273. t__syntr  proc near
  1274.           push bp        ; protect bp
  1275.           mov bp,sp      ; establish stack addressability
  1276.           mov bx,[bp].t_np0 ; set flag address
  1277.           sys_entr <byte ptr [bx]> ; enter system state
  1278.           pop bp         ; restore bp
  1279.           ret            ; return
  1280. t__syntr  endp
  1281.  
  1282.  
  1283. comment ~
  1284.  
  1285. t__syxit(flg)
  1286. char *flg;
  1287.  
  1288. This function expands the sys_exit macro for use by c functions.
  1289. ~
  1290.  
  1291. t__syxit  proc near
  1292.           push bp        ; protect bp
  1293.           mov bp,sp      ; establish stack addressability
  1294.           mov bx,[bp].t_np0 ; set flag address
  1295.           sys_exit <byte ptr [bx]> ; exit system state
  1296.           pop bp         ; restore bp
  1297.           ret            ; return
  1298. t__syxit  endp
  1299.  
  1300.           endps
  1301.  
  1302.           end
  1303.  
  1304.  
  1305.  
  1306. Listing 4      High Resolution Clock
  1307. (C) Copyright 1986 Ken Berry.
  1308. All rights reserved.
  1309. Copies may be made for non-commercial, private use only.
  1310. ~
  1311.  
  1312.           include tele.mac ; system defintions (listing 2)
  1313.  
  1314.           extrn t_syxtm:word ; system execution time accumulator
  1315.           extrn sys_dgrp:word ; data segment storage
  1316.           extrn sys_stat:word ; original register block
  1317.  
  1318.           public t__tick ; system tick interrupt service
  1319.           public t_astrm ; application task termination flag
  1320.           public tmr_dspl ; physical display pointer
  1321.           public tmr_dvsr ; timer period
  1322.           public tmr_ilck ; tick service reentrant interlock
  1323.           public tmr_sync ; synchronization function address
  1324.           public tmr_tkct ; tick clock
  1325.           public tmr_xtm ; tick service execution time
  1326.           public tmr__clr ; reset time base generation
  1327.           public tmr__int ; timer initialization function
  1328.           public tmr__rst ; timer termination function
  1329.           public tmr__sts ; read timer status
  1330.           public tmr__tmr ; restart hardware timer
  1331.           public t_rdclk ; read high resolution clock
  1332.           public t_rtactg ; psuedo time accumulator pointer
  1333.           public t_rtmark ; mark execution interval
  1334.           public t__rdclk ; read real time clock
  1335.           public td_ref ; clock update tick reference count
  1336.           public td_tct ; clock tick timer
  1337.           public td__set ; set time of day clock
  1338.           public td__upd ; update time of day clock
  1339.           public w__cdspl ; physical display update function
  1340.           public w__sync ; physical display synchronization
  1341.  
  1342. RLCINT    equ 80h        ; relocated alternate time base interrupt
  1343. TMRINT    equ 8          ; hardware timer interrupt
  1344. TMRPRT    equ 40h        ; timer (8253) port
  1345. TMRPRD    equ 19912      ; timer period (60 Hz rate)
  1346. ;TMRPRD    equ 9956       ; timer period (120 Hz rate)
  1347. INTPRT    equ 20h        ; interrupt controller (8259) port
  1348. TMRMSK    equ 01h        ; hardware timer interrupt mask
  1349. INTEOI    equ 20h        ; interrupt termination value
  1350. DSPCT     equ 1          ; 60 Hz interrupt rate
  1351. ;DSPCT     equ 2          ; 120 Hz interrupt rate
  1352. IDV0      equ 3          ; tmr_idv0 divisor
  1353. ISKP0     equ 776        ; tmr_ict correction value
  1354. ISKP1     equ 11         ; tmr_idv1 correction value
  1355. ISKP2     equ 38         ; tmr_idv2 correction value
  1356.  
  1357.           dseg
  1358.  
  1359. tmr_tkct  dw 0           ; interrupt counter
  1360. tmr_dct   db 0           ; display counter
  1361. tmr_ict   dw 0           ; tick clock (for time base generation)
  1362. tmr_dvsr  dw TMRPRD      ; 1/2 timer period
  1363. t_astrm   db 0FFh        ; application task termination flag
  1364. tmrflg    db 0FFh        ; system state flag (t__tick)
  1365. tmr_ilck  db 0           ; tick service reentrant interlock
  1366. tmr_idv0  db 0           ; clock time base generator
  1367. tmr_idv1  db 0           ; primary alternate time base generator
  1368. tmr_idv2  db 0           ; secondary alternate time base generator
  1369. tmr_dspl  dw 0           ; console display w_pwdw pointer
  1370. t_rtactg  dw 0           ; psuedo time accumulator pointer
  1371. t_rtrfct  dw 0           ; real time reference count
  1372. t_rttick  dw 0           ; tick clock phase
  1373. tmr_xtm   dw 3 dup (0)   ; tick service psuedo time accumulator
  1374. tmrpxtm   dw 0           ; prior psuedo time accumulator pointer
  1375. tmr_sync  dw offset pgroup:w__sync ; synchronization function pointer
  1376. td_ref    dw 0           ; clock update tick reference count
  1377. td_tct    dw 0           ; clock tick timer
  1378.  
  1379.           endds
  1380.  
  1381.           pseg
  1382.  
  1383. comment ~
  1384. t__tick                  system tick service
  1385.  
  1386. t__tick\\
  1387.  
  1388. Control only comes here in response to an interrupt from the system clock.
  1389. This function serves three purposes. It maintains the system clock, which
  1390. provides the current date and time for both system and application uses. It
  1391. also  performs an update of the first physical display. And finally it
  1392. terminates the execution interval for the current application task. 
  1393. ~ 
  1394.  
  1395. t__tick   proc far
  1396.  
  1397. ; reentrant lockout
  1398.  
  1399.           assume ss:nothing,ds:nothing,es:nothing
  1400.           sti            ; interrupts on
  1401.           push ds        ; protect ds
  1402.           push ax        ; protect ax
  1403.           mov ax,dgroup  ; establish data addressability
  1404.           mov ds,ax
  1405.           assume ds:dgroup
  1406.           mov al,INTEOI  ; terminate interrupt
  1407.           out INTPRT,al
  1408.           ilck al,tmr_ilck ; test for not reentrant call
  1409.           or al,al
  1410.           jz tick
  1411.           pop ax         ; restore ax
  1412.           pop ds         ; restore ds
  1413.           iret           ; return from interrupt
  1414.  
  1415. ; system interlock
  1416.  
  1417. tick:     mov t_astrm,0FFh ; terminate application task
  1418.           sys_entr tmrflg ; enter system state
  1419.  
  1420. ; set machine environment
  1421.  
  1422.           sys_sctx       ; save processor context
  1423.           push bp        ; protect bp
  1424.           mov bp,sp      ; mark stack location
  1425.           lea ax,tmr_xtm ; accumulate psuedo time
  1426.           push ax
  1427.           call t_rtmark
  1428.           mov sp,bp
  1429.           mov tmrpxtm,ax ; store prior pointer
  1430.  
  1431. ; real time system processing
  1432.  
  1433.           inc tmr_dct    ; remove display harmonics
  1434.           mov al,DSPCT
  1435.           xor al,tmr_dct
  1436.           jnz tick4
  1437.           mov tmr_dct,al
  1438.           push tmr_dspl  ; display physical window
  1439.           call w__cdspl
  1440.           mov sp,bp      ; restore stack pointer
  1441.           inc tmr_ict    ; increment interrupt counter
  1442.           inc tmr_tkct   ; increment tick clock
  1443.  
  1444. ; time base generation
  1445.  
  1446.           mov ax,ISKP0   ; long term time base correction
  1447.           xor ax,tmr_ict
  1448.           jnz tick1
  1449.           mov tmr_ict,ax
  1450.           call tick5     ; update system tick clock
  1451. tick1:    inc tmr_idv0   ; generate clock time base
  1452.           mov al,IDV0
  1453.           xor al,tmr_idv0
  1454.           jnz tick3
  1455.           mov tmr_idv0,al
  1456.           call tick5     ; update system tick clock
  1457.           inc tmr_idv1   ; primary alternate time base correction
  1458.           mov al,ISKP1
  1459.           xor al,tmr_idv1
  1460.           jnz tick2
  1461.           mov tmr_idv1,al
  1462.           int RLCINT     ; update alternate time base
  1463.           inc tmr_idv2   ; secondary alternate time base correction
  1464.           mov al,ISKP2
  1465.           xor al,tmr_idv2
  1466.           jnz tick2
  1467.           mov tmr_idv2,al
  1468.           int RLCINT     ; update alternate time base
  1469. tick2:    int RLCINT     ; update alternate time base
  1470.  
  1471. ; terminate interrupt service
  1472.  
  1473. tick3:    push tmrpxtm   ; restore original psuedo time accumulator
  1474.           call t_rtmark
  1475.           mov sp,bp
  1476.           pop bp         ; restore bp
  1477.           test tmrflg,0FFh ; test for interrupted system task
  1478.           jnz tick4
  1479.           xor ax,ax      ; terminate task
  1480.           mov tmr_ilck,al ; enable reentrance
  1481.           retn           ; near return to system task management
  1482.  
  1483. tick4:    sys__rctx      ; restore processor context
  1484.           cli            ; interrupts off
  1485.           mov tmr_ilck,0 ; enable reentrance
  1486.           pop ds         ; restore ds
  1487.           iret           ; return to interrupted task
  1488.  
  1489. ; update system tick counter
  1490.  
  1491. tick5:    mov ax,td_tct  ; test for no overflow
  1492.           inc ax
  1493.           cmp ax,td_ref
  1494.           jne tick6
  1495.           call td__upd   ; update clock
  1496.           xor ax,ax      ; reset tick counter
  1497.           mov td_ref,ax
  1498.           mov td_tct,ax
  1499. tick6:    inc td_tct     ; increment tick counter
  1500.           retn           ; return
  1501.  
  1502. t__tick   endp
  1503.  
  1504. comment ~
  1505. tmr__int                 initialize timer
  1506.  
  1507. tmr__int()
  1508.  
  1509. All data areas necessary for clock maintenance are initialized. The hardware
  1510. timer is programmed for the appropriate rate and its interrupt vector is made 
  1511. to point to sys_tmr. The original vector is relocated and will be used by
  1512. sys_tmr as the alternate time base.
  1513. ~
  1514.  
  1515. tmr__int  proc near
  1516.           call tmr__dsi  ; diable interrupts
  1517.           mov ax,dgroup  ; set data segment
  1518.           mov sys_dgrp,ax
  1519.           mov ax,cs      ; set code segment
  1520.           lea si,sys_stat
  1521.           mov [si].rcs,ax
  1522.           cli            ; interrupts off
  1523.           mov tmr_ilck,0FFh ; lockout t__tick
  1524.           mov bx,tmr_sync ; test for no synchronization function
  1525.           test bx,bx
  1526.           jz int0
  1527.           lea bx,tmr_sync ; synchronize timer interrupt
  1528.           call [bx]
  1529.           jmp short int1 ; continue
  1530. int0:     call tmr__tmr  ; start timer
  1531. int1:     call t_rdclk   ; set real time clock phase
  1532.           mov t_rttick,ax
  1533.           mov t_rtrfct,ax ; set reference count
  1534.           mov t_rtactg,offset dgroup:t_syxtm ; initialize time accumulator
  1535.           call td__set   ; set current time
  1536.           sti            ; interrupts on
  1537.           xor ax,ax      ; form 0
  1538.           push ds        ; protect ds
  1539.           mov ds,ax      ; relocate original interrupt vector
  1540.           mov di,ax
  1541.           cli
  1542.           mov ax,[di+4*TMRINT]
  1543.           mov [di+4*RLCINT],ax
  1544.           mov ax,[di+4*TMRINT+2]
  1545.           mov [di+4*RLCINT+2],ax
  1546.           mov ax,offset pgroup:t__tick ; set interrupt service
  1547.           mov [di+4*TMRINT],ax
  1548.           mov ax,cs
  1549.           mov [di+4*TMRINT+2],ax
  1550.           sti            ; interrupts on
  1551.           pop ds         ; restore ds
  1552.           call tmr__eni  ; enable interrupts
  1553.           ret            ; return
  1554. tmr__int  endp
  1555.  
  1556.  
  1557. comment ~
  1558. tmr__clr                 reset time base generation
  1559.  
  1560. tmr__clr()
  1561.  
  1562. The time base adjustment variables are reset. This function is to be called by
  1563. td__set when the time of day is initially set from a continuous clock. Nothing
  1564. is returned.
  1565. ~
  1566.  
  1567. tmr__clr  proc near
  1568.           xor ax,ax      ; zero time base generation variables
  1569.           mov tmr_idv0,al
  1570.           mov tmr_idv1,al
  1571.           mov tmr_idv2,al
  1572.           ret            ; return
  1573. tmr__clr  endp
  1574.  
  1575.  
  1576. comment ~
  1577. tmr__rst                 reset timer
  1578.  
  1579. tmr__rst()
  1580.  
  1581. The original interrupt service routine is restored and the hardware clock is
  1582. reprogrammed. However, the original hardware values are not available in this
  1583. edition. Therefore the original system state cannot always be restored.
  1584.  
  1585.  
  1586. tmr__rst  proc near
  1587.           mov tmr_ilck,0FFh ; lock out interrupt service
  1588.           push ds        ; protect ds
  1589.           xor ax,ax      ; restore original interrupt vector
  1590.           mov ds,ax
  1591.           mov di,ax
  1592.           call tmr__dsi  ; disable timer interrupt
  1593.           cli            ; interrupts off
  1594.           mov ax,[di+4*RLCINT]
  1595.           mov [di+4*TMRINT],ax
  1596.           mov ax,[di+4*RLCINT+2]
  1597.           mov [di+4*TMRINT+2],ax
  1598.           pop ds         ; restore ds
  1599.           xor bx,bx      ; restart hardware timer
  1600.           call tmr__str
  1601.           sti            ; interrupts on
  1602.           call tmr__eni  ; enable timer interrupt
  1603.           ret            ; return
  1604. tmr__rst  endp
  1605.  
  1606. comment ~
  1607. tmr__tmr                 restart hardware timer
  1608.  
  1609. tmr__tmr\\
  1610.  
  1611. Channel 0 of an 8253 timer is initialized to mode 3. The count in bx is then
  1612. programmed.
  1613.  
  1614.  
  1615. tmr__tmr  proc near      ; restart timer
  1616.           mov bx,tmr_dvsr ; set tele system tick period
  1617. tmr__str  proc near      ; set timer period
  1618.           mov al,20      ; reset 8253 (mode 0, count >= 8,192)
  1619.           out TMRPRT+3,al ; [> 6.8 msec]
  1620.           iowait
  1621.           out TMRPRT,al
  1622.           mov al,36h     ; initialize 8253 (mode 3, both bytes)
  1623.           iowait
  1624.           out TMRPRT+3,al
  1625.           mov al,bl
  1626.           iowait
  1627.           out TMRPRT,al
  1628.           mov al,bh
  1629.           iowait
  1630.           out TMRPRT,al
  1631.           ret            ; return
  1632. tmr__str  endp
  1633. tmr__tmr  endp
  1634.  
  1635. comment ~
  1636. tmr__sts                 read timer status
  1637.  
  1638. tmr__sts()
  1639.  
  1640. The returned value is the current count in the timer.
  1641. ~
  1642.  
  1643. tmr__sts  proc near      ; read timer status
  1644.           mov al,00h     ; set read mode
  1645.           out TMRPRT+3,al
  1646.           nop            ; allow timer chip to recover
  1647.           in al,TMRPRT   ; read count
  1648.           mov ah,al
  1649.           in al,TMRPRT
  1650.           xchg ah,al
  1651.           ret            ; return
  1652. tmr__sts  endp
  1653.  
  1654. comment ~
  1655. tmr__dsi                 disable interrupt
  1656.  
  1657. tmr__dsi()
  1658.  
  1659. The timer interrupt is disabled at the 8259 interrupt controller.
  1660. ~
  1661.  
  1662. tmr__dsi  proc near
  1663.           cli            ; interrupts off
  1664.           in al,INTPRT+1 ; disable timer interrupt
  1665.           or al,TMRMSK
  1666.           iowait
  1667.           out INTPRT+1,al
  1668.           sti            ; interrupts on
  1669.           ret            ; return
  1670. tmr__dsi  endp
  1671.  
  1672. comment ~
  1673. tmr__eni                 enable interrupt
  1674.  
  1675. tmr__eni()
  1676.  
  1677. The timer interrupt is enabled at the 8259 interrupt controller.
  1678. ~
  1679.  
  1680. tmr__eni  proc near
  1681.           cli            ; interrupts off
  1682.           in al,INTPRT+1; ; enable timer interrupt
  1683.           and al,not TMRMSK
  1684.           iowait
  1685.           out INTPRT+1,al
  1686.           sti            ; interrupts on
  1687.           ret            ; return
  1688. tmr__eni  endp
  1689.  
  1690. comment ~
  1691. t_rdclk                  read real time clock
  1692.  
  1693. t_rdclk()
  1694.  
  1695. The current value of the real time clock is read and returned.
  1696. ~
  1697.  
  1698. DMAREG    equ 0          ; refresh address DMA register
  1699.  
  1700. t_rdclk   proc near
  1701. rdclk0:   mov dx,DMAREG  ; set DMA register address
  1702.           call t__rdclk  ; read time
  1703.           mov bx,ax      ; store time
  1704.           call t__rdclk  ; read time again
  1705.           cmp ah,bh      ; test for interruption
  1706.           jne rdclk0
  1707.           ret            ; return
  1708. t_rdclk   endp
  1709.  
  1710. t__rdclk  proc near
  1711.           cli            ; interrupts off
  1712.           in al,dx       ; read time
  1713.           mov ah,al
  1714.           iowait
  1715.           in al,dx
  1716.           xchg al,ah
  1717.           sti            ; interrupts on
  1718.           ret            ; return
  1719. t__rdclk  endp
  1720.  
  1721. comment ~
  1722. t_rtmark                 mark execution interval
  1723.  
  1724. t_rtmark(np)
  1725. pointer *np;
  1726.  
  1727. The number of refreshes since the last call to t_rtmark is accumulated. Then
  1728. the reference count is reset. np points to the area that will accumulate the
  1729. number of refreshes to the next call. The returned value is the original
  1730. accumulator pointer.
  1731.  
  1732.  
  1733. t_rtmark  proc near
  1734.           push bp        ; protect bp
  1735.           mov bp,sp      ; establish parameter addressability
  1736.           call tmr__dsi  ; disable timer interrupt
  1737.           call t_rdclk   ; read real time clock
  1738.           mov bx,ax      ; protect current count
  1739.           xchg bx,t_rtrfct ; update reference count
  1740.           sub ax,bx      ; compute execution interval
  1741.           jnc mark1      ; test for no overflow
  1742.           neg ax         ; adjust count
  1743. mark1:    mov bx,t_rtactg ; accumulate execution time
  1744.           add ax,[bx]
  1745.           mov [bx],ax
  1746.           jnc markxit
  1747.           add word ptr [bx+2],1
  1748.           jnc markxit
  1749.           inc word ptr [bx+4]
  1750. markxit:  mov ax,bx      ; return orginal pointer
  1751.           mov bx,[bp].t_np0 ; set new accumulator pointer
  1752.           mov t_rtactg,bx
  1753.           call tmr__eni  ; enable timer interrupt
  1754.           pop bp         ; restore bp
  1755.           ret            ; return
  1756. t_rtmark  endp
  1757.  
  1758. comment ~
  1759. w__cdspl                 display physical buffer
  1760.  
  1761. w__cdspl(pw)
  1762. struct w_phys *pw;
  1763.  
  1764. Physical window pw is displayed.  This function is called by the system tick 
  1765. clock interrupt service function.  Nothing is returned.
  1766. ~
  1767.  
  1768. w__cdspl  proc near
  1769.           ret            ; return
  1770. w__cdspl  endp
  1771.  
  1772. comment ~
  1773. w__sync                  synchronize interrupt to display
  1774.  
  1775. w__sync()
  1776.  
  1777. The system tick clock timer is adjusted so that w__dsply executes just prior
  1778. to the vertical blanking interval.  Nothing is returned.
  1779. ~
  1780.  
  1781. w__sync   proc near
  1782.           call tmr__tmr  ; start timer
  1783. w__sync   endp
  1784.  
  1785. comment ~
  1786. td__set                  set time of day clock
  1787.  
  1788. td__set()
  1789.  
  1790. The clock is set to the current time.  Nothing is returned.
  1791. ~
  1792.  
  1793. td__set   proc near
  1794.           ret            ; return
  1795. td__set   endp
  1796.  
  1797. comment ~
  1798. td__upd                  update clock
  1799.  
  1800. td__upd()
  1801.  
  1802. The clock is updated based on the number of ticks since it was last updated.
  1803. The normal return (ax) is _F.  _E is returned if the call was locked out.
  1804. ~
  1805.  
  1806. td__upd   proc near
  1807.           ret            ; return
  1808. td__upd   endp
  1809.  
  1810.           endps
  1811.  
  1812.           end
  1813.  
  1814.