OSDev.org

Code: Select all

        XOR     AX,AX               ;Segment = 0000
        MOV     ES,AX
        MOV     AX,ES:[046Ch]       ;Get Timer Word..

Code: Select all

dec time_to_run
-> != 0 then iret
-> = 0

enqueue thread:

do nothing with the thread
-> put thread on the ran queue (high, med or low)
kill the thread
-> put it on the kill queue
thread wants to wait
-> put it on the wait queue
thread wants to go sleeping
-> put it on the sleep queue

dequeue thread:

-> take 1st thread with the highest priority from the ready list (I remove this item from the list)
   -> there is no ready thread? then put all items from the ran queues on the ready queues
-> is this a thread which will be killed?
   -> put it on the kill queue and dequeue next thread

Code: Select all

dd ptr 2 prev item
dd ptr 2 next item
rest of thread struc

Code: Select all

#define NULL '\000'

typedef struct {int dummy;} taskrec; 

typedef struct srec
{
   taskrec *tr;
   unsigned long int delta;
   struct srec *next;
} sleeprec; 

typedef sleeprec* sleepnode;
typedef taskrec*  tasknode;
typedef unsigned long int size_t;

void sched_remove(tasknode tr);
void sched_add(tasknode tr);
void* kmalloc(size_t s);

sleepnode sleepq = NULL;

void sleep(tasknode task, unsigned long int timer)
/* 
removes task from the scheduler queue, and adds it
to the sleep queue. The sleep queue is ordered by
the difference in clock ticks from each node, starting
from the first. Thus if a new node has to wait 5 ticks, and the
existing nodes have values of 2, 2, 0, 1, then the new node
is inserted between the third and fourth nodes, and assigned
a value of 1, and the node following it assigned 0, resulting in
a queue that orders as 2, 2, 0, 1, 0. 
*/
{
  sleepnode curr_node = sleepq, next_node = NULL, new_node = NULL;

  sched_remove(task);  
  // removes task from schedq but does not trigger a reschedule

  new_node = (sleepnode) kmalloc((size_t) sizeof(sleeprec)); // allocate new node
  new_node->tr = task;

  if (NULL  == curr_node)
  {
      new_node->next = NULL;
      sleepq = new_node;
  }      
  else if  (timer < curr_node->delta) 
  {
      new_node->next = sleepq;
      sleepq->delta -= timer;
      sleepq = new_node;
  }      
  else 
  { 
      next_node = curr_node->next;

      while ((NULL != next_node) && (timer >= curr_node->delta))
      {
           timer -= curr_node->delta;
           curr_node = next_node;
           next_node = curr_node->next;
       } 
    
       if  (NULL != next_node)
       {  
           next_node->delta -= timer;
       }

       new_node->next = next_node;
       curr_node->next = new_node;
  }
  
  new_node->delta = timer;
}

void awaken()
/* 
checks the sleeping tasks and wakens any that a ready to run
Should be called on every n clock ticks (where n is system dependent).
Each clock tick, the head node's delta value is decremented;
when it reaches zero, it is removed from the queue, along with 
any node that follows it which are also at zero.  
 */
{
   sleepnode next_node = NULL, curr_node = sleepq;

   if (NULL != curr_node)
   {
       (curr_node->delta)--;
       next_node = curr_node->next;
       
       while  (NULL != curr_node && 0 == curr_node->delta)
       {
           sched_add(curr_node->tr); 
           // adds tr to top of schedq but does not trigger a reschedule
           next_node = curr_node->next;
           free(curr_node);           // free empty node    
           curr_node = next_node;
       }
       sleepq = curr_node; // update global queue head to first non-zero node
   }
}