home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume44 / toy_os / part04 / mult_proc.cc < prev    next >
C/C++ Source or Header  |  1994-09-05  |  4KB  |  137 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /*
  3.  ************************************************************************
  4.  *
  5.  *        Multiprocessing under VM_UNT - Virtual OS
  6.  *
  7.  * The present file contains interfaces with the system library
  8.  * of VM_UNT.
  9.  * Important!
  10.  *    Turn off optimization while compiling the present flag. This
  11.  * would prevent the compiler from keeping too much data in registers
  12.  * across the function calls. A call to proc_switching(), either explicit
  13.  * or implicit (through the P-semaphor operation), leads potentially to
  14.  * the thread switching. As experience shows, some registers would not 
  15.  * be restored after the thread gets control back.
  16.  *
  17.  * Note, if the preprocessor symbol DEBUG is set, some debug information
  18.  * as to setting/releasing the locks, etc. is printed FYI.
  19.  *
  20.  ************************************************************************
  21.  */
  22.  
  23. #include "mult_proc.h"
  24. #pragma implementation "mult_proc.h"
  25.  
  26. #include "myenv.h"
  27. #include <setjmp.h>
  28. #include <std.h>
  29.  
  30. /*
  31.  *------------------------------------------------------------------------
  32.  *                   Semaphores
  33.  */
  34.  
  35. extern "C" {                 // VM_UNT library calls
  36.   void p(void *);
  37.   void v(void *);
  38.   int  sem_awaited(void *);
  39.   void * seminit(const char * name, const int size);
  40. }
  41.  
  42.                 // Create a semaphore with a specified name
  43.                 // and assign an initial value to it
  44. Semaphore::Semaphore(const char * _name, const int in_value)
  45. { 
  46.   assert( _name != 0 );
  47.   assure( in_value >= 0, "Initial value of the semaphore cannot be negative");
  48.   strncpy(name,_name,sizeof(name)-1);
  49.   value = in_value;
  50.  
  51.   assert( (_sem_ptr = seminit(name,in_value)) != 0 );
  52. #ifdef DEBUG
  53.   message("\nSemaphore '%s' (ID=%x), in_value %d has been set up",name,
  54.       (int)_sem_ptr,value);
  55. #endif
  56. }
  57.  
  58.                 // P-semaphore operation
  59. void Semaphore::operator -- (void)
  60. {
  61. #ifdef DEBUG
  62.   message("\nAbout to perform P-operation on '%s' (ID=%x), value %d",
  63.       name,(int)_sem_ptr,value);
  64. #endif
  65.   value--;
  66.   asm("pushl %esi");
  67.   ::p(_sem_ptr);
  68.   asm("popl %esi");
  69. #ifdef DEBUG
  70.   message("\nWoke up after sleeping on P-operation on '%s' (ID=%x), value %d",
  71.       name,(int)_sem_ptr,value);
  72. #endif
  73. }
  74.  
  75.                 // V-semaphore operation
  76. void Semaphore::operator ++ (void)
  77. {
  78. #ifdef DEBUG
  79.   message("\nAbout to perform V-operation on '%s' (ID=%x), value %d",
  80.       name,(int)_sem_ptr,value);
  81. #endif
  82.   value++;
  83.   ::v(_sem_ptr);
  84. }
  85.  
  86.                 // Check to see if somebody is waiting on
  87.                 // this semaphore
  88. int Semaphore::awaited(void)
  89. {
  90.   return ::sem_awaited(_sem_ptr);
  91. }
  92.  
  93. /*
  94.  *------------------------------------------------------------------------
  95.  *             Threads of CPU control
  96.  */
  97.                 // System calls in VM_UNT
  98. extern "C" {
  99.                 // Create a thread. Return 0 if we're
  100.                 // in the child thread, and 1 otherwise
  101.                 // (kind of like fork())
  102.   int newproc(const char * name, const short priority);
  103.   volatile void endproc(void);    // Terminate the thread
  104. }
  105.  
  106. static char Was_stack_saved = 0;
  107.  
  108.                  // Create a thread with a specified name
  109.                 // and have it run the procedure we want
  110.                 // until it is over
  111. Thread::Thread(const char * name, const short priority, Thread_body((*body)))
  112. {
  113.   if( !Was_stack_saved )
  114.   {
  115.     Was_stack_saved = 1;
  116.     extern int _stackinit;        // The following instructions save
  117.     asm("movl %esp,__stackinit");    // the stack of the calling proc
  118.     asm("addl $28,__stackinit");    // 28 = (4+3) long words in stack
  119.   }
  120.  
  121.   assert( name != 0 );
  122.  
  123.   if( !newproc(name,priority) )
  124.   {                    // We're in the child thread now
  125. #ifdef DEBUG
  126.   message("\nRunning a thread '%s', priority %d\n",name,priority);
  127. #endif
  128.     body();
  129. #ifdef DEBUG
  130.     message("\nThread '%s' is through\n",name);
  131. #endif
  132.     endproc();
  133.   }
  134.                     // We're in the parent thread now
  135. }
  136.  
  137.