Concurrent Programming

• Multithread
  Multithread has been introduced for the better system throughput, less in-core memory, and easier asynchronous programming. Moreover, if you have multiprocessor machine, your program may run faster!
  
  • System Throughput

    	Process	Thread	Process/Thread
    Creation	3.2ms	0.014ms	229
    Switch	0.1-0.2ms	0.01-0.02ms	10

    
    
  • Less Memory Requirement for Concurrency Control

    	Process	Thread
    TCB in core	8-10k	128 byte
    TCB in disk	64k	4K

    
    
  • Better real-time response
    
  • Rational programming for multiple activities
    
  • Utilization of Multiple Processors
    
  
  
• Two-level Multithread in Solaris
  
  • LWP (light weight process) for the kernel to bind activity to multiple processors
    
  • Thread for the library to dynamically bind activity to LWP
    

  In the OS kernel, thread (LWP) is the unit for allocating CPU. In user applications, thread is used to describe parallelism and to issue multiple system calls at the same time.

  
  
  

• Thread Model in the EusLisp
  Evaluation of arbitrary Lisp forms can be assignd to different threads. Each thread has its own stack context where local variable bindings are represented. Therefore, variable, function and label names in the let, lambda, flet, labels, catch-throw, block-return forms are thread local. On the other hand, references to objects in the heap are global, since the heap is the shared resource in the whole process. For examples, forms such as symbol-value, defun, defclass, property-list, cons, send, instantiate, etc., have global effects.

  A exception is the special variable which has the dynamic scope and extent. Since the value of a special variable is restored when its dynamic scope disappears, shared access to these special variables may cause hazard. Therefore, special variables are treated as thread local variables, and they should not to be used as global variables. In order to share the variable-value binding among threads, symbol-value should be referenced.

• Invokation of threads
  When a computation is submitted to a thread, the requester prepares arguments in the corresponding thread-port object, and posts a signal via a semaphore. The other thread finishes evaluation, it puts the result in the result slot of the thread-port object, and signals the done-semaphore. Whenever the requester wants to receive the result, it awaits for the done-sem, and reads the data from the thread-object port.

  

• Thread Pool
  To create threads each time concurrent computation is needed is not a good idea. Although the thread creation time is fast enough compared with the process creation time, it is still costly since relatively large amount of memory has to be allocated as the stacks to the thread, and the memory page attribute has to be changed to detect stack overflow by issueing a system call. In EusLisp, we expect sufficient number of threads are pre-created and are put in the process-global thread pool before thread invokation. Threads that are not assigned with computation are linked in the free-list.