Chapter 13th implementation of the process and thread classes

the 13th Chapter the realization of process and thread class   Multithreading refers to the ability to run multiple tasks at the same time within a process, with each task being done by a separate thread. A thread is the basic unit in which a process runs, and multiple threads can be run concurrently in a process. If the program is set to multi-threaded, you can improve the efficiency and processing speed of the program. Multiple threads share the resources of a process, and the scheduling and switching of the process is performed in a 10ms clock tick timer interrupt program. If a thread gets the CPU, it is impossible to switch out until the next tick arrives, unless you give up the CPU.

Although all are preemptive scheduling, the process is the dynamic priority preemptive scheduling, while the thread is fixed priority, plus the message first priority preemptive scheduling, user process thread scheduling also contains message-driven event procedure processing. Process scheduling, thread scheduling is done in the "clock tick" timer interrupt program, and ultimately run in-process threads, there are 2 kinds of scheduling has a forbidden preemptive mode. When a process is going to share a resource with a process or a thread wants to operate on a shared resource within the process, it is set to suppress preemptive mode, and the mode is released until it is complete. This is similar to a synchronous lock, the "clock tick" timer interrupt program is not dispatched when the preemptive mode is disabled, and the next "clock tick" timer interrupts to be dispatched if the mode is dismissed. Be aware that the process of the forbidden preemptive mode, just do not do process scheduling it, does not mean not to do thread scheduling; Note: The process lock is only X (System parameter, default 10) "Clock tick", more than will be automatically unlocked by the system, when the process of time slices run out, if the set process lock is also relieved. A fair program should be written to unlock resources to be unlocked when they are used, and to allow other processes or threads or objects to run. The system needs to monitor those processes or threads or objects in the lock resource, which will be reflected in the log process. If a thread is to manipulate the public resources of this process, then it should call the System method Key_thread (), lock the thread dispatch, similarly, if you want to manipulate the public resources of all the processes, then it should call the System method Key_process (), lock the process scheduling, the system method is "atom" Of   First, the Process class

Process_main () is the process code entry at the time the process is dispatched; All threads are property sheets of the pooled process. The process has 2 modes: The process mode of the wireless path, the threading mode. The system has these 2 kinds, and the user process implicitly inherits one of the classes. These 2 system classes have different Process_main () main methods, as well as some simple, less than 1E methods: These methods are described later or in the second chapter of the revised version.

Process_wait (); After saving the priority count, clear 0, wait for the block to return. Pwret
Process_sleep (); After saving the priority count, clear 0, sleep blocking is returned. Plret
Process_yield (); Priority count clear 0, concession to other processes in the scheduling cycle; blocking returns. Pyret
Process_pend (); Save priority count after 0, process scheduling, return to high-priority process. Ppret
Process_stop (); Process end returns, resource recycling, process revocation. Psret
Process_dispatchmessage (); system messages that process signals and processes.
Process_init (); Initialization of the common part of the process
Process_postmessage (); Adds a message to the thread message buffer and starts the appropriate thread.
Process_sendmessage (); Direct translation and invocation of message processing.
Send_message (); Sends a message to the user, or to the kernel, or to the external system Message Queuing ring.
Key_process (); Lock process scheduling.
Clr_key_process (); The process unlocks after the shared resource operation has completed.
Get_vnode_add (_process/_file, pid/file_num); Gets the process (file) v node pointer method.
Vnode_get (attribute variable name); Gets the various attribute variables within the V node, such as UID, GID, and so on.
Vnode_set (attribute variable name, numeric value); Sets the individual attribute variables within the V node, such as UID, GID, and so on.
The V-node is a combination of the file I node and the directory entry in memory.

1. Process Mode class:

All of this class of processes are common to the same system main method, the system will be based on the PID call corresponding to the user main (); The highest bit of PID is 1, which means the first run of the process, the second high is 1 is the process class process, and 0 is the thread class process.

The low 13 bits of class process_pro{//PID are process numbers.
Process_main (PID) {//Process mode class Master method; occupancy: 7W.
Process_init ();//The initialization of the common part of the process, which is required for the first run of the process.
LOOP:
H2 = H12; Reads a message from the local bus hardware controller into this process.
BT0 h2.3.w.31, LO1; User message jumps.
Process_dispatchmessage ();//system method; process signal, process system message.
JMP LOOP; Process the next message
LO1:
Main (); Execute user-written process message processing code, user code entry, user class.
JMP LOOP; Unconditionally skips processing the next message, looping.
}

process_xmub{//Process small mode attribute table; 256E System Management area.
bu248e dx_table{//Object header list, which becomes the current process when the base address is in the A0 register.
The 992 object numbers, the first 160 are read-only, and the next 832 are readable and writable. Of the 16-bit object number
The high 6 bits are the object operation flags, and the lower 10 bits are the object numbers.
bu2w [+] lf_tab; The class method table, 0 is the system class, 1 is this class, and 2-31 is the method library DLL.
bu2w [+] thread_lf_tab; Thread class method table, 128 thread group run () entry and length.
The high 7-bit thread number is the thread class number that belongs to, if you have only one thread class, 64K of similar thread;
The system sets the contents of the Thread class table to the same pointer to the thread class run () and the method length of the class.
Process patterns are not used by the process class, and these items are empty, 0.
bu2w [Dx_tab]; Object table, dx_tab.63, except for user-defined Dx_tab, the remaining
Objects are all formed by the compiler package. You can set up a root object for each thread class, DX_TAB.I;
All of the object property sheets in the thread that belong to the class are packaged together. The compiler will set these object property sheets as
Relative to the root address; the operation is DX_TAB.I. The name of the object. Variable name. To conserve resources, we cannot set
Too many object numbers to be placed. The compiler translates dx_tab.i into object numbers, and object names. The variable name is the offset address.
The alias of the DX_TAB.I is Di, and the alias of dx_tab.63 is D.
bu2w [768] gx_tab; A shared (dynamic) object table that corresponds to some dynamically allocated, disposed objects.
}
BU256 signal; 256 signal bitmaps.
BU256 [3] GX_NO_WT; 768 Public dynamic shared object number bitmap variable.
bu1k sblocked; Shielding code (corresponding signal, dynamic variable, object bitmap).
}
};

In the code, opening and manipulating a file, you must first declare the file property sheet and include variables such as the number of files returned by the log file service process, the number of dynamic or static objects, the contents of the file (or dynamic objects), the location of the file, and so on.
file{
BU32 FD; File descriptor (descriptors). File number
BU48 F_pos; The current location in the disk file.
BU16 Dx_no; The operation flags of Di or GX_TAB.I and Flow container objects, read, write, etc.
Buxe F_stream; The X-row-bit container for the file stream. When sending a message to the log file service process, submit the
Object number: File.f_stream. The relative offset address of W, and the F_STREAM.LEN.W flow container size.
}
System can open 1M files, the maximum number of open files per process is 64K. gx_no_wt,768 a public dynamic shared object; The master is used for interprocess communication. In APO, such objects are heavily used, and who applies and who releases them. Shared object name GX_TAB.I is the name shared by all processes, but the shared object of the user process is to be installed by the system before it can be used, if the process request is available, or if another process submits it. Otherwise, an empty object operation is interrupted and destroyed. The contents of the Object header list are installed and released by the system.

User system Message Queuing, which is a ring of 16K messages. The current user process may be 0.1%, or if the average time the user process processes a message is 20ns, the loop needs 320ns. All user processes are shared with a user system message queue. Each read into a user message, the user system message queue in the corresponding location is cleared 0, so that the system can write a new message, and find the next user message, which is hardware implementation. User program cannot read a system message, otherwise the user operation "System variable" error, is destroyed. However, the user can process a user message that the system reads into the H2 row storage area. The user is primarily writing the code and Declaration in main (); Main () is something like that.
public static void Main (String args[]) {...}, you know.

2. Thread mode class for the process:

All of this class of processes are common to the same system main method, the system will be based on the PID call corresponding to the user main (); The highest bit of PID is 1, which means the first run of the process, the second high is 1 is the process class process, and 0 is the thread class process.

The low 13 bits of class process_pro{//PID are process numbers.
Process_main (PID) {//Process system method; occupancy: 11W.
Process_init (); Initialization of the common part of the process
LOOP:
THREAD_DD ();//Thread scheduling 32ns--452ns
LOOP1:
H2 = H12; Reads a message from the local bus hardware controller into this process.
JZ LOOP; All the messages in a lap are processed to jump
BT0 h2.3.w.31, LO1; User message jumps.
Process_dispatchmessage ();//system messages that process signals and processes.
JMP LOOP1; Process the next message
LO1:
BT0 h2.3.w.30, LO2; Instant message processing jumps.
Process_postmessage ();//Add a message to the thread message buffer and start the appropriate thread.
JMP LOOP1; Process the next message
LO2:
Process_sendmessage (); Direct translation and invocation of message processing.
JMP LOOP1; Process the next message
}
process_xmub{//Process small mode attribute table; 1KE System Management area.
bu248e dx_table{//Object header list, which becomes the current process when the base address is in the A0 register.
The 992 object numbers, the first 160 are read-only, and the next 832 are readable and writable. Of the 16-bit object number
The high 6 bits are the object operation flags, and the lower 10 bits are the object numbers.
bu2w [+] lf_tab; The class method table, 0 is the system class, 1 is this class, and 2-31 is the method library DLL.
bu2w [x] thread_lf_tab;//Thread class method table, 128 thread group run () entry and length.
bu2w [Dx_tab]; Object Table,
bu2w [768] gx_tab; Shared (dynamic) object table.
}
BU256 signal; 256 signal bitmaps.
BU256 [3] GX_NO_WT; 768 Public dynamic shared object number bitmap variable.
bu1k sblocked; Shielding code (corresponding signal, dynamic variable, object bitmap).
bu64k thread_wt;//64K Thread-priority bitmap.
bu64k tblocked; Line Cheng Shield code.
bu64k thread_run_wt;//thread runs the bitmap, thread_wt the results of the BIC tblocked.
}
};

Second, the thread class

Thread_main () {///main thread system method; occupancy: 2w,1e. Thread number 0, highest priority.
Main (); Executes user-written code, user code entry.
Wret; Pseudo-return instruction, actually jump, JMP thread_wait (); and return.
}

Thread_wait () {///when the front-thread waits for a message to block the method. Occupation: 4W; Time: 4ns
A0. PROCESS_XMUB.TBLOCKED.PRR.L = 0;
Masks the current thread. System method
Compiled into: R1 = A0; R1 = + process_xmub.blocked; R1. PRR. L = 0;
The process_xmub.blocked is directly compiled into a relative line address corresponding to the A0. All the
This is true of the system variables for the process. PRR (R6) is the task status register, and the low half word is the current thread number.
Ret }

after Thread_wait (), the thread is in a blocked wait state until a related message arrives before it is awakened. For Thread_main (), it is possible to run once and never wake up again.

Thread_start (Thread object name) {//Start a thread method, r0l equals the thread number.
r0l = thread number; The thread number is given by the compiler, occupation: 4W; Time: 4ns
A0. Process_XMUB.tblocked.R0L = 1; Turn on masking.
RET }

However, the syntax used is usually the thread object name. Start (); The compiler is still the same after translation. If the thread object name to the thread number of the translation is done by the compiler, that is, the symbol table is a thread object name corresponding to a thread object number; no problem. But if the thread object name can be changed, then it is troublesome; you change from the console, the compiler does not know. The problem can be solved, from the Object Header table, a search, until the match, or use the hash value of the name to search; but there's no need for that. Or, create a symbol table in the process, or build a registry in the system, and faint. So, the name of the object, the name of the dynamic variable, the class name, the method name, the static variable name, etc., created in the APO program, cannot be changed after compiling! Thread object name, thread object array member, procedure name, signal name, dynamic variable name, class name and so on the mapped object number, method name Mapping relative address, all by the compiler allocation, establishment.

1. Thread Scheduling

The maximum number of threads is 64K, or 64K threads, and the Line 0 thread is the main thread, which must be in each process. The priority is divided into 128 groups, with a maximum of 512 threads per group, and the smaller the thread number, the higher the priority. We construct a 64K bit bitmap variable thread_wt, the bit order from 0 to the maximum 64K, corresponding to the thread number; thread_wt.0 is the main thread. If a user writes a thread that does not specify a priority, the compiler is usually assigned in groups of 2 or later; Of course, you specify; that will be assigned as you specify. The distribution of the thread number is the management of the resource small mode, the small mode attribute table is not only the thread number, but also the static object number, the dynamic variable number, the event procedure number, the class number and so on. However, these are all assigned by the compiler in the APO.

For THREAD_WT allocation code, 1 is idle, 0 is used, for the Shield code tblocked,1 is allowed, 0 is forbidden. Therefore, the allocation code BIC shielding code, that is, the allocation code to seek anti-and shielding code, the THREAD_RUN_WT run code, 1 is operational, 0 is forbidden. Thread scheduling, is to find the first lowest bit of the run bitmap to get the corresponding sequence number, and then from the Object Header table, according to the group ordinal to find the corresponding code entry, goto. This is similar to invoking resource administrators. OK, the system new method: Process _ object _ Management, JI_DX_GL (). Message procedures and threads are still very different, we usually take a few execution time very short message event processing, put in the message process execution; All the events are processed before being handed to the thread to run. The message process is a bit like the first half of the interrupt, and the thread is the second half of the interrupt.

JI_DX_GL (0.allot/release.0. Number of bitmap lines, 1.no, A0. Process_xmub, A0. Bitmap variable) {
Assign, no is 0, release No is to give you the serial number (thread number). To give a bitmap of that group number.
Variable. Occupancy: 22W. Time-consuming: Release 20ns, allocate 15ns + bitmap line count NS
B2 = R0; B3 = R1; Cmp. Z r1l, #0; If it is assigned, jump.
JZ Allot;
R2 = + r1l>>8; Copy only the corresponding line
YJMK. E = (R2).     E The assignment R2 a row that the pointer points to.
SS1; Releases the 1 digits corresponding to the ordinal number.
(R2). E = yjmk.     E Return
Ret
Allot://This segment may be merged with the Administrator Method Gkliyk (), just worse (R3) = B4;.
COPY. E (YJMK, R3, r0l);//post-compilation 4 instructions, time consuming: 3ns + R0L/2 NS
SS1; Distribution.
BT0 PSR.  YJ, UIBT; Fail to return;
r0l = b2l;
COPY. E (R3, YJMK, r0l); Success is a callback. 4W
R0 = B3; return results
UIBT:
Ret
}

Thread_dd () {//thread scheduling method. Occupancy: 14W. Time: Max 15*28 + + = 451ns
Failure, 16*28 + 2 + 22550 = 23000 ns = 23us
r4h = 16; Up to 16 cycles
R3 = A0. THREAD_RUN_WT;
Tdd:
JI_DX_GL (0.allot.0.16, 1.0);
Copy 16 rows to find the high priority thread bit number; fail, next 16 lines
BT1 PSR. YJ, Ihgs; Success, jumping.
R3 = +16; Pointer +16, continue.
r4h-;
JNZ TDD;
Thread_run_wt_bic ()///There is no running thread to re-run the bitmap for the next scheduled cycle.
Ret
Ihgs:
r0l = >>9; Gets the thread group number.
R1 = A0.thread_lf_tab. r0l. W.W; R1 the word address that corresponds to the thread class number for the object Header table.
JZ Thread_error; The result is 0, and skip error handling is not installed.
PPC = (R1). W.W; R1 content as thread entry base to send PPC, jump to corresponding thread
Entrance. Returned to the process code block after the thread executes.
}

After the thread gets the CPU, the bits in its corresponding run bitmap are automatically cleared by the JI_DX_GL () method, allowing other threads to run. Of course, to become a selfish thread, you can also clear r0l thread number of the highest bit, during thread run, A0. THREAD_RUN_WT. r0l = 1; Well, illegal use of system-managed variables, compiler error, thread in this area read and write, the system will destroy it! At this point, unless there are higher priority threads than you, otherwise only selfish threads can run. In the code of either thread or procedure, you can dynamically generate a new thread or process, or you can hang yourself, or someone else, A0. process_xmub.blocked. Thread number = 0; Shielding, only the Wait () method is implemented, otherwise extinguished, no longer participate in scheduling. A thread can call the Wait () method from any state to enter the exit state, and the thread will not exist until the message wakes up if it waits to exit.
Thread_run_wt_bic () {///BIC runs the bitmap during the dispatch cycle. 23W, time-consuming approx.: 22.55us
R2 = A0. Process_xmub;
r0l = 2K; R1 = R2 + 256; Loop 2K times, R1 = Process_xmub. Thread_wt
r0h = 0;
R2 = + 512; R2 points to the corresponding shielded bitmap, PROCESS_XMUB.TBLOCKED.E
TRWB:
R31 = (R2).  W.W; R30 = (R1). W.W; Cyclic BIC.
R4 = R31 BIC R30;
JZ TRWB1; No bit to run, jump.
r0h+;
TRWB1: (R3). W.w= R4;
r1+;  r2+;  r3+; r0l-;
JNZ TRWB;
CMP r0h, #0; When all threads of a process are out of status, the process is forcibly terminated.
JZ TRWB2;
r3l = r0h;
Get_vnode_add (_process, PID); Gets the process (file) v node pointer method.
(R0). Thread_n.z.z = r3l; The number of running threads for the process v node is saved,
RET TRWB2: Pwret; Process hangs, JMP process_wait ();
}

Object Header table: A table of 2W object property tables in the order of 8-bit class numbers, object numbers, or method table entry pointers (block numbers, line start addresses, object space sizes).

Class symbol table: A table of class items arranged in class number order, which is the object that the compiler program constructs, and uses. Each class item occupies 4 rows of storage space, and 2K class items occupy up to 8KH. Class Entry: The first 2 behavior class inherits the relationship word count, which identifies the class number above the 32 parent class. Line 3rd is a subclass variable, which identifies 16 subordinate subclass numbers. For a specific class, line fourth: 16-bit one parameter, method table length, number of methods, number of objects in this class, number of property items in the property sheet, size of the property sheet, and so on. An application declares an object's property sheet, which the compiler needs to parse, the inheritance relationship of the class to which the object belongs, and to correctly compile an offset address for the object member variable. For example, object A, inherit B, C, D, E, F, and B, C, D and inherit A1,e, F and inherit A2. So, the compiler first gets the inheritance of the relationship class: B, A1, C, A1, D, A1, E, A2, F, A2, a bit schema ordering the rest: B, A1, C, D, E, F, A2. Then, the compiler removes those inheritance declarations, and the resulting object format should be: A, B, A1, C, D, E, F, A2. A row in the front, and other categories of objects disorderly row. You have to write a.a1, a.b.a1, A.E.A2, a.a2 and so on each relationship, the compiler can give the correct offset address, no diamond problem. If a programmer wants to manipulate tens of thousands of objects directly, it is too messy to be manipulated, starting with dozens of root objects. Therefore, the compiler is under the guidance of the programmer, and all objects should be packaged. Di. The object name. The last member object. Variable, that's a lot easier. Put a whole bunch of middle ... removed, the compiler should be able to give the correct variable offset address. That C + + virtual function, I was half a day do not understand, inexplicable; maybe a c + + bug. Originally, the calculation of the variable offset address is the compiler thing, and the user program does not have the relationship between the bird hair.
2, the implementation of the thread
1), Thread creation method Thread_create (priority group number PRIORITY_NO, Number of dynamic object lines);

       compiler to create an object number, if the code does not set a priority group number; That default is created from the second set, such as an empty location; Gets the thread number, establishes the object list item, usually the new thread is inherited from a thread class, and its method relative to the entry is known. Then, if it is a dynamic thread, request a dynamic object's memory allocation, dynamic object number, create a thread class object, initialize.   Set the corresponding bit of the thread priority bitmap, open the Shield start () method, and put it into a operational state; the wait () method clear 0 The shield bit to enter the stop state. The design thread class must contain the run () method, which is the entry for the thread. The general contract for the method run is that it may perform any required operations.

   the attribute tables for thread classes are usually: thread entry, thread-owning class number, size, priority group number, Thread state 1W, thread-defined system management variables, and so on.

   The user creates a new thread and puts it into a running state; it's easy to write the following line in the code block:
Thread class name    thread name  = new ( Priority group number PRIORITY_NO, number of dynamic object lines);
The number of dynamic object rows is 0, the Thread object property sheet is created by the compiler. When the

compiler compiles to this line, it assigns the thread number according to the priority group number, obtains the final priority group number, and the class number is known, and sets the corresponding bit of the group thread priority bitmap, then compiles to:

Thread_create () {//Occupy: 8W; time: NS
    r31h = class number; r31l = Priority group number; r30h = number of dynamic object rows; r30l = thread number;
    cmp.z r30h, 0;//compiler Create thread object property sheet, jump.  
    JZ TC1;
    MEM_NEWH (r30h); Dynamically allocates contiguous r30h row memory, returning r0l as the dynamic object number.
TC1:
    corresponding thread class. init (); //Initialize thread object.     r1l = r30l;
    A0. Process_XMUB.blocked.R1L = 1; Turn on masking, put on run
    RET
} //Return results R31, R30, R0.

2), return of the thread

    use 5 return pseudo-directives:
wret   correspondence    jmp  thread_wait (); Wait for message, block return
sret   corresponding    jmp  thread_sleep (T), sleep wait, block return
PRET    corresponding   jmp& nbsp Thread_pend (); branch fixed-point waiting for message, blocking return. After wake-up, you can go back to the point of the code branch, rather than go back to run (); For example, a branch at a certain point, open a file, and then after the completion of the message, of course, I hope to return to that point, continue to execute. The

yret  corresponds to the   jmp  Thread_yield (), the thread withdraws back, or the next cycle may run again.
tret  corresponds to   jmp  thread_stop (), thread termination is returned. Resource recycling, thread revocation, no zombie thread like the main thread.
 
      using pseudo-directives, you can use fewer e-texts. These methods are made up of very little code, very simple. Before the pseudo-directive returns, we can also start another thread object, such as the name of the thread object. Start (); Other Java methods don't seem to be much use. The wake in APO is basically based on the signal, the message mechanism, the synchronization problem in APO is very simple, the first thread to obtain the CPU, it can not be interrupted work 10ms; If you think the code is running out of time, then you Key_thread (); lock thread Dispatch. Remember to unlock after the shared resource operation has been completed; Clr_key_thread (). The

estimates that the method code for the full authoring process, thread class can reach 35E and is worth celebrating. A little gadget, it's so long, I don't know how many mistakes.
Three, signal, message, event procedure

1, message format

  The message format in     apo is only one; the signal is also considered a message. The message type has the system message, the non-system message, the MSGV highest bit, also divides into the immediate processing type, and the thread processing type, MSGV the high order. The remaining 6 bits can represent 64 message types, and each message type has a maximum of 256 message values. In the message format, the destination address, and the source address is 2W; The message content is only 2 W. At present, there is only one kind of system message type: signal, there are only 3 types of User message: Command message, window message, notification message, file message. When replying to a message, you can call the Send message method that reverses the message header. In addition to the message header format, the message content is very much related to the message type.

Example 1: The usual customer/service message format. The
bu1e MSG {             //Request message structure.   bu16  fu_cpu_id;      //Server CPU number, a system with a maximum of 64K CPU support.
  bu16 fu_process_id;//Low 13-bit is the process number of the maximum 8K service party.
  bu16 fu_thread_id; //Low 16-bit is the thread number of the process for the service party.
  bu16 ku_cpu_id;    //client-side CPU number.
  bu16 ku_process_id;//Low 13-bit is the process number of the maximum 8K client side.
  bu16 ku_thread_id; //Low 16-bit is the thread number of the client side of the process.
  bu16  msgv; //Low 8-bit message value with high 8-bit message type.
  bu16  dx_id; //target or submitted object number.
  bu16  Dx_add;//The relative offset address of the object.
  bu16  Dx_len;//The size of the object.
  bu64  txc3; //64-bit additional information, or the location and information of the mouse where the message was sent.
  bu32  time; //message sent, in units NS. }

BU1E MSG {//Response message structure.
BU16 ku_cpu_id; Client-side CPU number, a system with a maximum of 64K CPU support.
BU16 ku_process_id; The low 13-bit is the process number of the maximum 8K client side.
BU16 ku_thread_id; The low 16-bit is the thread number of the client side of the process.
BU16 fu_cpu_id; The server-side CPU number.
BU16 fu_process_id; The low 13-bit is the process number of the maximum 8K service party.
BU16 fu_thread_id; The low 16 bits are the thread number of the process for the service party.
BU16 MSGV;//low 8-bit message value with high 8-bit message type.
BU16 dx_id; The target or the number of the submitted object.
BU16 Dx_add; The relative offset address of the object.
BU16 Dx_len; The size of the object.
BU64 TXC3; 64-bit additional information, or the location and information of the mouse where the message was sent.
BU32 time; The time that the message was sent, in units NS. } 2. SignalTo be continued ... , taking into account the need to save local memory space, the file directory system needs to be greatly changed .....

Chapter 13th implementation of the process and thread classes