The 11th chapter of database management class implementation

                                                              the 11th chapter of database management class implementation

The file directory system is a class, its method table is only one, and the property sheet is special, can contain many classes of objects, and can be dynamically increased; it can be said that the file directory system is a multi-class set of objects. The database is a subdirectory of the file directory system, and from a certain point of view, we can also view the file directory system as a database. In fact, many resource management have the characteristics of the database, such as memory, disk space, process, a thread in a process, objects, classes, open file numbers, messages and so on management. We think of these and so on as system objects, so how do we manage these system objects? What are their abstract points? In any case, objects are made up of tables, data variables, and sub-tables, and the data is a container for bits; just the size and the way you save it. A table is made up of variables, which can also be another table or dynamic table; The members of a dynamic table may also be a table; There are 2 basic forms:
1, the table table, the table again ... A tree-like structure, typically a file directory system.
2. A dynamically changing table, that is, a table of changes in the number of members; If the members of a dynamic table have the same type, they are called linear tables.

There are 2 forms, typical of the database we use, the database as a directory node, and the child node as a heap of table files under the directory. The file table is usually composed of the file header attribute table and the file Body attribute table, if we put the attributes of the basic invariant part of a table in the file header, and the linear table as the file body; That is the table file. At this point, the members of the linear table are usually called records. A directory can be thought of as a linear table, and its member records are files.

In theory, dynamic tables are not exhaustive, but resources are limited. In APO, the number of files and directories under a volume, which is the number of I nodes, cannot exceed 4G. The number of files and subdirectories in a directory cannot exceed 4G. The member size of a dynamic table cannot exceed 4G, and the members of a dynamic table can be a table. Therefore, a linear table of records such as more than 4G; you can put it in another table file. Theoretically, a database can be 16E records, not in fact, because it cannot exceed the disk space of a volume 4G data block = 8PB.

         Dynamic table has 2 modes: large mode, no more than 4G members size, small mode, the number of members is not more than 64K. The management of resources, 2 modes are possible to use. For example, local memory management: Local memory has 64K blocks, in a continuous block allocation, Release management mode is small mode. Each chunk has 64K rows, and the management mode that is allocated and released in contiguous rows is the large mode. Another example is the usual database: the number of linear table files, the number of records in the linear table is the use of large mode, and the number of fields in a table is in small mode. Another example of a volume of disk space 4G data block management: A unit is 64K blocks of data, a volume has 64K of units. A page field has 64 page extents, a page area has 64K pages, and a page is 256 rows, or 256H. Therefore, in the continuous unit, continuous page area allocation, release of the management mode is small mode. The management mode of continuous data block, continuous page allocation and release is the large mode. In any case, there are 4 basic ways to manipulate members of a table: Add, delete, modify, query. The last 2 methods are usually implemented by different applications, and the first 2 methods can be abstracted as a general method. From another point of view, the addition and deletion can be seen as the allocation and release of resources. If we use a bits to represent a resource unit, the resource unit may be a contiguous row, or a contiguous block of data, or a record, or a file, or a process, or a thread in a process, or a continuous page, or a contiguous page, or a contiguous unit, or an I node, or an open file number in a process, a field in a linear table, a class number in a process, or an object number in a process, a message number, a procedure number, and so on. This corresponds to the small mode, which requires 64K bits to represent, or bu64k a;  64K bitmap variable a corresponds to a small mode. The large mode requires a bitmap variable of 64K 64K bits to describe it. A 64K bit bitmap variable occupies only 256H of storage space, but the large mode needs to occupy 256 blocks of storage space, which is much more. To reduce the waste of space, we are usually dynamically generated for large patterns. Initially just allocates a bitmap variable data block that has 256 64K bit bitmap variables, and can manage 16M units in large mode. If it is not yet satisfied, then apply to allocate a bitmap variable data block ... Eventually, a block of N (n <= 256) bitmap variable data is generated. As long as we write the allocation and release methods of the large and small patterns in the System method table, then all the program classes will benefit; No duplicate code is required. Add, delete a record in a database table, or a file in a directory, or a contiguous block of data in disk space, or a table file under a database,or a contiguous page in disk space, or an I node in disk space, or a contiguous row of local memory, and so on, all of which are called allocation and deallocation methods in large mode. Add, delete, or remove a field from a database table, or an object number or class number or thread number or procedure number or message number or the number of open files in a process, or a contiguous unit in disk space, or a contiguous section of pages in disk space, or a continuous chunk of data in a local memory, and so on is the allocation and deallocation method that is called in small mode. The bitmap in APO is a bit 1, which indicates idle, and a bit of 0 indicates occupancy. Adding, removing is only the operation of the bitmap variable, not the specific contents of the object. For example, delete a file, just release some bits in the bitmap variable that represents the disk space occupied by the file, and if the space is not occupied by another file, then the space is the contents of the original file.

A unit is a dividing unit of space. A unit, if it is the XX number, it is very good to do; it corresponds to a bit in a large, small pattern; The result is a bit ordinal. In any case, a unit is a specified bit container. Memory, disk space bit container specification is fixed, have: Line h, block 64KH, page 256H, page Area 64K page, Unit 64K data block, page Domain 64K page area, Volume 64K units. However, such as a record in a database table, etc., the unit is not necessarily fixed. A record may be 600H, perhaps a page, perhaps 10 blocks of data, and so on. In any case, they end up with a fixed-bit container that requires disk space and memory space to load. A record of the unit size, the No. 0 record in the memory space of the start address will be in the table file header performance, the No. 0 record in the disk space at the beginning of the address will be in the table file directory entries are reflected. Why use continuous units to allocate, release? The goal is to cancel the low-speed list mode. If a table file size is 1G data block, if you use a linked list mode, you need about 1G times I/O and track positioning to find the final record; almost 3,000 hours. Even if you put the list head pointer in the public file to increase the speed, it also takes up more than 4GB of space. The use of continuous unit allocation, space, time to save more, 1G data blocks can be allocated a continuous 16K units, even if it is gradually generated, there will not be many segments, the list can be very small. Why is the disk space location and size of the file placed in the directory entry? If you want to delete a directory with 1G files or subdirectories, then just I/O and release a directory file; otherwise, 3,000 hours is fast.

Corresponding Small mode:
A field in a database table, or an object number or class number or thread number or a process number or message number or an open file number in a process, or a contiguous cell in disk space, or a contiguous page area in a process, or disk space, or a contiguous block of data in local memory. Dividing the space into one unit is 1/64k.

Corresponds to the large mode:
A record in a database table, or a file in a directory, or a contiguous block of data in disk space, or a contiguous page in disk space, or a file I node in disk space, or a contiguous row of local memory. Dividing the space into one unit is 1/4g.

1. Small Mode Management

In the APO kernel, a multi-function auxiliary hardware module with 64K bits is integrated, and allocation and release are performed within a single method. Request allocation, or release of a contiguous unit; we need to copy the 64K bitmap variable into the hardware module, then execute the allocation, or release the command, and then return the 64K bit of the bitmap variable. Although the hardware module's execution time is only 10ns, it takes 256ns to copy the entire bitmap 256 rows back and forth. So, we need to think about it; just copy the desired line (just 1ns) into the hardware module to increase the speed. To this end, add a variable BU32 A1; The high 16 bits of the A1 represent the maximum number of consecutive 1 values in the bitmap, and the lower 16 bits represent the row ordinal of the value. In this way, we start by judging whether a1h satisfies the requirements, yes, we only copy the relevant lines from the beginning of the a1l line to allocate, no, copy the entire bitmap of 256 lines to allocate; A1 reset. The release is relatively simple, just to copy the related rows. For discontinuous units, that is, the management of a bit, is much simpler. We first copy 16 lines, SS1, if the success of 36ns, the failure to copy the next 16 lines, up to 16 cycles.

Small Mode property sheet:
xmub{//256H + 3 W.
bu64k XMUWT; Small mode manages bitmap variables; 256H.
BU1W MAXLX1; The maximum number of bits in a bitmap variable that is 1 consecutive and the line number to which the starting bit number belongs.
BU1W Ksxyu; The number of idle units managed by the bitmap variable.
BU1W Uijiu; The actual number of units in the bitmap variable management.
}

Allocation: The number of consecutive units or digits of the application that are to be applied; exits, returns the unit number of the number of consecutive units to start, and the number of units of the maximum consecutive units of the bitmap. Failed, status register PSR sign, PSR. YJ = 0.
Release: entry, number of consecutive units released and start unit number, exit, return the maximum number of consecutive units of the bitmap for the start unit number.

Administrator method: Gkliyk (Command parameter variable B2, parameter variable B3, &XMUWT bitmap variable address, &maxlx1);
The parameters in the method are always corresponding to the R0-R3 registers that are pressed in.
The hardware module YJMK has 3 parameters and control registers B2, B3, B4. Execution instruction: SS1; So, when you call the Gkliyk method, you need to pass in these 3 related parameters.
bu64k YJMK; The 64K-bit hardware module YJMK variable, divided into 256 lines, 256 bits per line.

The

is related to bit operations:
B2H: High 8 bits are instruction attributes, and low 8 bits are script codes. The highest bit is the SS1 start bit; when finished, b2h.15 = 0.
B2L: The lower 16 bits are the number of bitmap rows you want to copy in (that is, your bitmap size).
B3h: A high 16-bit is the number of consecutive 1 digits that you apply or release.
B3L: The low 16-bit is the number of consecutive 1-digit returns that are requested for the start bit address, or the number of consecutive 1-digit start-bit addresses released. The
b4:  Returns the result: the maximum number of consecutive 1 digits of the bitmap and the line number to which the start bit belongs.
    Returns the result for saving B4, as well as the variable address to R3 for the maximum number of consecutive 1 digits of the bitmap and the line number to which the start bit belongs. The
saves the returned results of the B4, so that you know how to judge the next time, and you don't need to put the whole bitmap in, just one line, and the speed can be much faster. The

Hardware module YJMK has a maximum of 16 scripts and only 4 bits in the 8-bit command code are valid. There are 5 commonly used bitmaps related to the bitmap: number 0-5 instruction code.
Allot (Assignment instruction), release (release instruction) = Set (position 1), CLR (bit clear 0), CMP (Compare)
Compress (compression), insert (insert), replace (replace) Trinity CIR instruction.

Directive function: After the
SS1 instruction is started, it takes about 6-10ns to complete, during which the user's CPU is idling until the SS1 is completed before the next instruction is executed.

Allot (Assignment Directive): The search bitmap satisfies b3h 1 consecutive digits of the beginning bit address to b3l, success Psr.yj = 1, also b3h 1 consecutive digits of 1 all reversed (to 0, indicating occupancy). After the search succeeds, the CLR directives are executed as partially cleared 0. The bitmap has been searched, failed, bitmap content unchanged, PSR. YJ = 0;b2h.15 = 0.

Release (releasing instructions): Sets the number of successive bits that you request to release the starting bit address of the b3h consecutive bit 0 is all set to 1, the release succeeds; The return result (R3) = B4 is the maximum number of consecutive 1 digits of the bitmap and the line number to which the start bit belongs.

CMP (unsigned comparison directives): At most, only the values in 256 rows are compared; the bitmap content is unchanged.
B2H: High 8-bit low 4 bits are CMP attributes: Character/character comparison, relationship/evaluation, relationship with: equals/not Equals, equals: less than equals/greater than equals, not equal to: greater/less than, if evaluated: Max/min. 0000x1xx,0000x0x0
The B3:32 bit is the value you need to compare to the 32-bit value in n rows. N <= 256
The B3H:16 bit is the value you need to compare to the 16-bit value in n rows.
B4L: return Result: R0 = B4L is the first qualified word or character start address; b4h unchanged, can be used as record number high half word
The bitmap has been searched, failed, and PSR. YJ = 0;b2h.15 = 0.

A comparison has to be only the first qualifying word or character start address; You can save B4, then SS1 until the bitmap is searched, Psr.yj = 0. In this way, multiple SS1 can be obtained, and more than one record in 256 rows is eligible. You can write your own method for working with multi-functional hardware modules, not necessarily calling Gkliyk ().

CMP directives are very efficient for database queries, and if a field is mapped to a character or word value, a numeric condition query is required. Then, we can copy the 256H = 2KW = 4KZ data segment into the hardware module to compare, if the average one data segment can query to 1-8 qualifying records, then the in-Memory database table lookup speed of the word mode is about:
2k/0.27us ~= 7G Record/sec, the character way is about: 14G record/second, that is about 15 billion records/second.

CIR instruction: Compress (compression), insert (insert), replace (replacement).
Compression: You can clear the specified characters or words in the 1-256h, and compress the storage.
Insert: A character or Word can be inserted into the specified character or word position in the 1-256h.
Replace: You can replace a specified character or word in 1-256h, or a character or word in a specified position.

Detailed later used to re-introduction;

The methods in the system can be thought of as "atoms"; you don't have to worry about the synchronization contention caused by interrupts when calling methods, even if the kernel is not preempted. The method in the system runs less than 0.3us and is typically less than 0.1us.

Gkliyk () {//Occupy space 25w,4h; time: 256 rows, 276ns; Occupy R31, R0, R2. R1, R3 unchanged
R31 = &YJMK; B3 = R1; B2 = R0; R0 = instruction attribute. instruction. Number of rows N,
r0h = &0x000F;
copyh+ (R31), (R2), r0l); transmit; r2+, r31+ until r0l-= 0.
SS1; Start execution, Time 10ns. Psr. YJ = 0.
Switch (r0h) {//4-bit Jump table, r0h value jump; PPCL = (PPCL + 1). r0h.
Allot; Release clr CMP; CIR; RET (reserved); RET; .... A total of 11 ret.
}
Allot:
BT0 PSR.   YJ, UIBT; Fail to return;
ALL1:
r0l = b2l;
copyh-(R2), (R31), r0l); Success is returned; r2-, r31-until r0l-= 0.
R0 = B3;         (R3) = B4; return results
UIBT:
Ret
RELEASE:CLR:
JMP ALL1; Release or set to 1-bit or continuous position 1 is bound to succeed, jump callback.
The CLR must be successful in 1-bit or continuous-bit-clear 0, skipping callbacks.
CMP:CIR:
R0 = B4; Regardless of failure, success is returned; Psr.yj is judged in your code;
RET//17+H/2 ns,16 row is 25ns.

}

This is a common method; Before, you should also implement the specific is the line to start, how many lines.
For example, apply 3 contiguous blocks of data to local memory.
ALLOT1 (0.allot.0.1, 3.0, &mem_xmub, &mem_xmub. MAXLX1);

ALLOT1:
Cmpz (R3).  H, r1h; The maximum continuous value of 1 can meet the requirements?
JNN ALT1; is jumping
R0 = 0.allot.1.0; No, the entire bitmap 256 row needs to be copied.
Gkliyk ();
BT0 PSR. YJ, Uibtil; Failed, skipping error handling.
Ret
ALT1:
R2 = + (R3).       L Only one line is copied, the total time is 25ns.
JMP Gkliyk ();
Uibtil://Error handling ...
....
Ret

Another example is to release an object to local memory, which occupies 300 contiguous blocks of data, and the block number begins with address 1000. Because the maximum number of consecutive 1 values and start addresses in the bitmap will change when released. Preferably, the entire bitmap is copied into it; it takes more time, and less than 0.3us. So, the call is:
Gkliyk (0.release.1.0, 300.1000, &mem_xmub, &mem_xmub. MAXLX1);

Another example is in a process where the code needs to request an open file number. If you want to be simple, just:
Gkliyk (0.allot.1.0, 1.0, &ji_fs_no_xmub, &ji_fs_no_xmub. MAXLX1);
But it will take about 0.28us of time; To save time, we first copy 16 lines, SS1, if the success of 36ns, failed to copy the next 16 lines, up to 16 cycles.

2. Large Mode Management

Local memory space is inherently limited, if you declare a word variable in your code, you also assign a page (4KB); That's unreasonable, it's ridiculous. The granularity of memory allocation in modern operating system is still relatively coarse. In APO, for local memory with continuous row allocation method is more reasonable than other, can say no fragmentation problem, granularity can be as small as 1H (32B, 1W). The granularity of disk space is 1 page 256H (8KB), it seems to be a bit large, but the file is less than 2KB is placed on the I node, without disk space allocation, so it is very reasonable.

A contiguous row allocation within a local data block, a contiguous page allocation within a page area, a contiguous block of data within a cell, an I node number assignment, a block record number assignment, and so on. The allocation method for these items is required to use a linear table, because allocations are made in 4G space, to use a bitmap variable of 64K 64K bits; In the original, continuous row or continuous page allocation is quite complex; it is more complicated to feel the chain list. Allocation and release are required to be divided into 2 methods; Newh and Releaseh.

A unit data block of 64K resource units allocated as a large mode, requires a pointer to that unit block, and a bitmap variable of 64K bits per bit for one unit. There may be more than one block of units allocated for this continuous resource unit, and one block can hold 256 64K bitmap variables, corresponding to the unit blocks allocated by the 256 contiguous resource units. Theoretically, 64K block blocks require 256 blocks of bitmap variable data to be managed. In fact, the bitmap variable data blocks are dynamic and grow on demand. Initially, only a bitmap variable data block, and 256 bitmap variables in the bitmap variable data block are not all used. For example, a file directory system; A unit refers to an I node that represents a file or directory. Creating a new file or directory is a request to allocate an idle bit in large mode, that is, assigning an I node. There is a similar addition to adding a record to a database table, assigning a continuous n page to a file, and so on. The unit ordinal of the large mode is 1W, and the maximum number of consecutive units is the half word 1Z representation. Because there are up to 256 bitmap variable data blocks, each bitmap variable data block has a maximum of 256 bitmap variables, so the high 16-bit high 8 bits of the unit ordinal are the bitmap variable block ordinal, the lower 8 bits are the bitmap variable ordinal in the bitmap variable data block, and the lower 16 bits are the bit ordinal numbers of the corresponding bitmap variables.

Large Mode property sheet: There will be a unit number in disk space, but only a block number in memory.
dmub{//4KH + 48H + 1W
bu1z [WTKP]; 256 bitmap variable/block, local memory block number pointer array; no or unassigned 0
bu1z [Wtkxu]; An array of the number of free bitmap variables in each block of 256 bitmap variables.
bu1z [MMLX1]; The maximum number of values in each of the 256 bitmap variables with a maximum continuous of 1.
bu16h [mlyxuw1;//] An array of 256 maximum 16-bit maximum arrays of 256 bitmap variable blocks that are up to 1 in a row.
BU1W MAXLX1; The maximum number of bits in a bitmap variable that is 1 consecutive and the line number to which the starting bit number belongs.
}

In each of the 256 bitmap variables, some bitmap variables may not have been used, and the unused bitmap variable, which corresponds to a maximum continuous of 1 16-bit maximum, is 0, but all bits of the bitmap variable are initialized to 1. The 16 bits of the number of free bitmap variables are free, up to 256. There is no bitmap block used, its block number pointer is 0, its corresponding bitmap variable maximum number of consecutive 1 is the maximum value of 0, its corresponding free bitmap variable number is: 0x0100.

NEWH allocation method: The first step, the maximum number of consecutive 1 of the maximum value of the array to find whether there are requirements of the bitmap variable block sequence number; Copy the corresponding block sequence number of 256 maximum consecutive 1 16-bit maximum array (16H), compare to get the required number of bitmap variables ; Copy the corresponding bitmap variable into the hardware module for allocation. Return Result: 32-bit unit ordinal, time consuming 378ns. No, in the second step, in the array of free bitmap variables, look for the ordinal number of the first bitmap variable block that is greater than or equal to 1, failure-skipping error handling, success, copying of the free bitmap variable into the hardware module for allocation, and the number of free bitmap variables-1.

newh{///Large mode allocation method: Database record, contiguous memory row, disk continuous data block, continuous page allocation.
Entry: R0-R4, return R0: The number of consecutive rows or consecutive blocks or consecutive pages of the application, and the start address.
R0-R4 = (7.cmp.0.16, consecutive 1 digits of the application. 0, &dmub, &dmub. MAXLX1, & variables)
Occupancy: 44W, 6H. Time consuming: Non-new bitmap variable, 378ns. No, 411ns, 32.418us
R27 = R2; R28 = R2 + 16; R29 = R2 +32; R30 = R2 + 48;//R27-r30 point to dumb members
R2 = R29;    R24 = R1; R2 = &dmub. MMLX1; Save R1.
Gkliyk (); Returns R0 = The first qualifying character start address (the ordinal of a bitmap variable block number). 25ns
BT0 PSR.  YJ, #ne3; Failed to jump, look for bitmap variables that have not yet been assigned. To this, 33ns
r26h = r0l; Save the block number to r26h,
R0 = 7.cmp.0.16; The bitmap variable ordinal that satisfies the required maximum value of the bitmap variable
NE1://This time: 343ns
R2 = R30 + r0l<<4; R2 256 bitmap variable maximum array member that points to block ordinal blocks.
Dmub. MLYXUW1. Block ordinal member (R0L&LT;&LT;4, 16 rows per member).
R25 = R2; Save to R25.
Gkliyk (); Returns R0L = The first qualifying character start address (the bitmap variable ordinal).
r26l = r0l;
NE2://This time: 314ns
R2 = R27. r26h + r0l<<8;//R2 points to the bitmap variable that matches the criteria: WTKP. Block ordinal + variable line number.
R0 = 0.allot.1.0;  R1 = R24; Assign instructions to restore R1.
Gkliyk (); Assign and copy the 256 rows of the corresponding bitmap variable.
R25. r26l = (R3).  H Holds the maximum value of the bitmap variable maximum array.
r23l = r0l; Saves a 16-bit ordinal number in a variable bitmap.
R2 = R25;
R0 = 4.cmp.0.16; The maximum value in the array of 256 bitmap variable maximums.
Gkliyk (); Returns R0L = The first qualifying character start address (the ordinal of the maximum value).
R29. r26h = R25. r0l;//the maximum value of the saved maximum value. Dmub. MMLX1. r26h
r0h = r26l + r26h <<8; Returns the r0h as a unit ordinal, a bitmap variable ordinal in a block.
r0l = r23l; Returns R0 as the unit ordinal.
Ret
Ne3:
R2 = R28; R2 = &dmub. Wtkxu.
r1h = 1;
R0 = 7.cmp.0.16; The number of 256 free bitmap variables is greater than 1 block ordinal.
Gkliyk (); Returns R0L = The first qualifying character start address (block ordinal).
r26h = r0l;
Cmpz R28. r0l, #0X0100;//is a free block?
JZ Ne4; Yes, jump apply 1 bitmap variable data blocks.
R28.          r0l-; Number of free bitmap variables minus 1
R1 = 0; R0 = 6.cmp.0.16;
JMP ne1; The first 0 variable ordinal, and assigned. This paragraph is time consuming 35ns
Ne4:
ALLOT1 (0.allot.0.1, 1.0,&mem_xmub, &mem_xmub. MAXLX1);
R27.  r26h = r0l; Save Block number
Ky_init (); The block is initialized to a full 1;dmub.mlyxuw1.r0l<<4 of 16 rows initialized to 0. Time consuming, 32.01us
r26l = 0; R28. r26h = 0X00FF;
JMP NE2; This paragraph is time consuming 32.071us
}

releaseh{
Entry: R0-R4, return R0: The unit number of the maximum number of consecutive units in a bitmap.
R0-R4 = (0.release.1.0, the number of consecutive 1 digits released, &dmub,&dmub. MAXLX1, Unit serial number)
Occupancy: 12W, 2H. Time-consuming: NS
r1h = r1l;  r1l = r4l; r30l = r4h;
r30l = >>8; r30h = r4h <<8; R30L is the block ordinal, r30h is the bitmap variable ordinal
R2 = R2.        r30l + r30h; R2 pointing to the corresponding bitmap variable
Gkliyk (); Released, if the entire bitmap is released, the maximum value becomes 0, and the bitmap variable is idle +1, as 0x0100
We need to release the block. No, save Max, max value, max Max value and save.
。。。

}

Dizzy, the fee is so strong, so complex content, code amount of 10H, but also constantly modified. From the target code volume 512H is still very remote, the core of the system is only 2 instructions 2W, even the process, thread scheduling is a few lines of code; It seems that the application of 90% of the code to complete the system, a variety of frameworks, patterns are integrated into the system.

3. Database connection

For the connection of such resources, can be regarded as a large mode; In theory, the database service process can support 4G connections. You can build a dynamic thread class that can manage 64K connections and become a schema framework to integrate into the system. Connection resources, categorized into processes, thread classes. Database applications also include: transaction logs, display management, message processing, event procedures, and so on. The first 2 items are basically integrated into the system; to say the truth, look complex, what window, key class, etc., write out the total amount of code that is 10H. After 2 items, the minimum more than half is integrated into the system. Write the operating system, second seconds to consider the synchronization of inter-thread communication problems; I will be as efficient and simple as possible. Many traditional synchronization methods I may give up, the user is basically no need to consider synchronization issues. The transaction log for the database application, which resolves some data synchronization issues. Whether the synchronization problem is on a process, a thread class, or another article is still under consideration. This chapter is verbose to this, eh, saliva more than rice.

The 11th chapter of database management class implementation