Abstract:
A garbage collection apparatus that performs (1) scavenging processing for specifying unused cell blocks from among a plurality of cell blocks, some of which can be reached from a specified root cell block via one of a set of trays, tracing one or more cell blocks in a chain-like manner by referencing each of the one or more cell blocks, and others of which cannot be reached in this manner and are referred to as the unused cell blocks, each of the set of trays being specified by a second type address and holding a first type address, each of the plurality of cell blocks (a) being specified by a first type address and (b) including a plurality of cells that each hold one of a second type address and a numerical value, and (2) compaction processing for relocating each of the specified unused cell blocks so as to form a continuous memory area, and updating each first type address that is held in a tray and corresponds to a cell block so as to specify a cell block following relocation, the garbage collection apparatus comprising: assuming means for making an assumption as to whether a second type address is stored in a cell included in a first cell block, so as to avoid a situation in which the second type address is mistakenly assumed not to be a second type address; and specifying means for specifying an unused cell block using the scavenging processing by assuming that a second cell block is referenced by the first cell block, the second cell block being specified by a first type address, the first type address being held in a tray specified by data held in the cell that is assumed to be holding the second type address.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    The present invention relates to a garbage collection apparatus for performing scavenging and compaction on cells using trays.  
           [0003]    2. Description of the Prior Art  
           [0004]    An application uses a heap for performing dynamic memory allocation. The heap includes a plurality of cells, as shown in FIG. 27. Cells that are not used by the application are referred to as unused cells. The application reserves a number of cells required for an application process as a cell block.  
           [0005]    [0005]FIG. 28 shows an example of a heap. In the drawing, the heap includes a root cell block, cell blocks  1  to  5 , and an unused cell area. The unused cell area is a collection of unused cells that have not been allocated.  
           [0006]    When reserving memory the application forms reference relationships between cell blocks so that a reserved cell block can be referenced by other cell blocks. In FIG. 28 such references are shown by polygonal lines. A cell block  4  is referenced by a root cell block, a cell block  2  by the cell block  4 , and a cell block  5  by the cell block  2 . The root cell block is a cell block that is the start of the reference relationship.  
           [0007]    To explain in more detail, the application holds a valid reference showing a start cell of the reserved cell block in a cell included in another cell block. A valid reference is a cell address or similar. To give one example shown in FIG. 28, the application holds a valid reference  3  showing a start cell in a cell block  2 .  
           [0008]    However, cell blocks that cannot be traced (reached) from the root cell block may be generated when the application is executing processing for a particular process. Such cell blocks are said to be unreachable (dead). Processing performed to free unreachable cell blocks and collect the freed cell blocks together to form an unused cell area in which cell blocks are once more capable of being used is known as garbage collection. A device for executing this processing is known as a garbage collector.  
           [0009]    The garbage collector performs scavenging (relocating unreachable objects) and compaction (also known as compactifying). In FIG. 28, the garbage collector performs scavenging to return unreachable cell blocks  1  and  3  to an unused state, and then performs compaction to gather up the plurality of unused cell blocks into one unused cell area. When this processing is performed, the garbage collector updates valid references held by cells in order to maintain reference relationships between cell blocks.  
           [0010]    Various refinements have been made to the algorithm used by the garbage collector. The following is an explanation of three garbage collectors in the prior art.  
           [0011]    [0011]FIG. 29 shows a structure of a heap in a first prior art. In the drawing, the heap includes cells, and reference flags corresponding to each cell. The garbage collector performs scavenging as follows:  
           [0012]    (1) sets ‘in use’ flags indicating whether cell blocks are in use or not at 0 (here, an ‘in use’ flag uses 1 bit from each cell block);  
           [0013]    (2) reads a valid reference held in a root cell block;  
           [0014]    (3) determines that a cell block at a location indicated by the read valid reference is in use, and sets the ‘in use’ flag for the cell block at 1;  
           [0015]    (4) refers successively to each of the reference flags for the cell block determined to be in use, and retrieves all of the reference flags set at 1; and  
           [0016]    (5) reads valid references held in cells corresponding to each of the retrieved references. The garbage collector repeats the processing of (3) to (5) for all of the cell blocks that are reachable from the root cell block.  
           [0017]    Following this, the garbage collector performs the following compaction:  
           [0018]    (1) calculates a reference value for a start cell after compaction for all cell blocks with an ‘in use’ flag set at 1;  
           [0019]    (2) rewrites reference values for all cells that have an ‘in use’ flag and a reference flag set at 1 with the reference values calculated in (1); and  
           [0020]    (3) shifts cell blocks with an ‘in use’ flag set at 1 to the reference locations calculated in (1).  
           [0021]    [0021]FIG. 30 shows a heap memory for a second prior art example. As shown in the drawing, the heaps includes reference flags, cells, and trays. A cell block holds a valid handle indicating a tray, and the tray holds a valid reference indicating a start cell in a cell block. Reference relationships between cell blocks are indicated indirectly by using trays.  
           [0022]    For example, a cell block  4  holds a valid handle  1 , which indicates a tray with a valid handle  1 . The tray with the valid handle  1  holds a valid reference  3 , which indicates a cell block  2  in which the valid reference  3  is located. Thus, cell block  3  can reference cell block  2 .  
           [0023]    The garbage collector in the second prior art performs the following scavenging:  
           [0024]    (1) specifies, via trays, cell blocks that are reachable from the root cell block, and sets the ‘in use’ flags for these cell blocks at 1 (this processing is similar to that in the first prior art);  
           [0025]    (2) changes valid references for trays which are not referenced by any cell block to NULL references.  
           [0026]    As one example of (2), the garbage collector updates the content of a tray with a valid handle  0  and a tray with a valid handle  2  that are not referenced by any cell block to a NULL reference. A NULL reference indicates that a tray is unused. Thus, cell blocks  1  and  3 , whose valid references  1  and  6  were held by the trays with the valid handles  0  and  2  prior to updating, are freed by the garbage collector to form an unused cell area.  
           [0027]    Following this, the garbage collector in the second prior art performs compaction as follows:  
           [0028]    (1) calculates a reference value for a start cell after compaction for all cell blocks with an ‘in use’ flag set at 1;  
           [0029]    (2) overwrites trays holding a valid reference with the reference values calculated in (1); and  
           [0030]    (3) shifts cell blocks with ‘in use’ flags set at 1 to a reference location calculated in (1).  
           [0031]    In the example shown in FIG. 30, cell blocks  4  and  5  are shifted forward by an amount corresponding to the size of the freed cell blocks  1  and  3 . Here, the garbage collector updates the content of the trays so as to maintain references from a root cell block to a cell block  4 , and the cell block  4  to a cell block  2  and a cell block  5 .  
           [0032]    [0032]FIG. 31 shows a heap for a third prior art. The third prior art is one example of what is known as a conservative garbage collector. Such technology is disclosed in more detail in  Garbage Collection in an Uncooperative Environment  (Hans-Juergen Boehm and Mark Weiser,  Software Practice and Experience Vol.  18, pub. September 1988, pages 807 to 820).  
           [0033]    Here, the heap holds pointers (references) to cell blocks at a start of each cell block. The garbage collector in the third prior art performs the following scavenging:  
           [0034]    (1) sets ‘in use’ flags indicating whether cell blocks are in use at 0;  
           [0035]    (2) reads a valid reference held in the root cell block;  
           [0036]    (3) determines whether a cell block at a location indicated by the read valid reference is in use;  
           [0037]    (4) reads content at a start location of a cell block determined to be in use, and makes an assumption as to whether the read content is a reference value.  
           [0038]    The garbage collector repeats the above processing (3) to (4) for all cell blocks that are reachable from the root cell block.  
           [0039]    In FIG. 31, the polygonal lines show reference relationships between cell blocks.  
           [0040]    The garbage collector in the third prior art makes assumptions as to whether cells contain numerical values or references, and performs garbage collection in accordance with the results of these assumptions. However, the garbage collector may mistakenly assume that a numerical value is a reference. For example, in FIG. 31, the garbage collector mistakenly assumes that a numerical value 6 is a valid reference. The curved line in the drawing shows the referencing that is performed based on this mistaken assumption. Since the garbage collector mistakenly assumes the numerical value 6 to be a valid handle  6 , a mistaken reference from cell block  2  to cell block  3  is produced.  
           [0041]    The garbage collector in the third prior art can perform scavenging, but not compaction. The reason for this is that if compaction is performed when such mistaken assumptions have been made, numerical values which have been mistakenly assumed to be handles will be updated.  
           [0042]    As explained above, the garbage collectors in the first and second prior arts perform scavenging and compaction, and the garbage collector in the third prior art performs scavenging alone, to keep the heap in a state such that memory of a size required by the application can be reserved.  
           [0043]    However, since the garbage collectors in the first and second prior arts use reference flags, reference flags are set while an application is being executed. Consequently, the processing load placed on the processor is increased, and the time required to execute the application is longer than that for an application that does not perform garbage collection.  
           [0044]    Moreover, the garbage collector of the second prior art performs compaction at high speed, but, since handles are used, a larger amount of memory needs to be reserved than for the first prior art.  
           [0045]    The garbage collector of the third prior art does not use reference flags when the application is executed, and so the processing load during execution of the application is lower than for the garbage collector of the first and second prior arts. However, the garbage collector of the third prior art does not perform compaction since numerical values may have been mistakenly assumed to be references. When compaction is not performed, the unused area is fragmented, and the number of small areas that cannot be recycled increases.  
         SUMMARY OF THE INVENTION  
         [0046]    The present invention may be realized by a garbage collection apparatus that performs (1) scavenging processing for specifying unused cell blocks from among a plurality of cell blocks, some of which can be reached from a specified root cell block via one of a set of trays, tracing one or more cell blocks in a chain-like manner by referencing each of the one or more cell blocks, and others of which cannot be reached in this manner and are referred to as the unused cell blocks, each of the set of trays being specified by a second type address and holding a first type address, each of the plurality of cell blocks (a) being specified by a first type address and (b) including a plurality of cells that each hold one of a second type address and a numerical value, and (2) compaction processing for relocating each of the specified unused cell blocks so as to form a continuous memory area, and updating each first type address that is held in a tray and corresponds to a cell block so as to specify a cell block following relocation, the garbage collection apparatus comprising: assuming means for making an assumption as to whether a second type address is stored in a cell included in a first cell block, so as to avoid a situation in which the second type address is mistakenly assumed not to be a second type address; and specifying means for specifying an unused cell block using the scavenging processing by assuming that a second cell block is referenced by the first cell block, the second cell block being specified by a first type address, the first type address being held in a tray specified by data held in the cell that is assumed to be holding the second type address.  
           [0047]    This enables the garbage collection apparatus to use trays to specify cells, and update first type addresses held in trays when performing compaction. Since the actual content of a cell is not updated, effective high-speed compaction can be achieved. Furthermore, the garbage collection apparatus does not use reference flags or similar to exchange information with an application when scavenging and compaction are performed. As a result, there is no need to reserve memory for reference flags, and an excessive processing load is not generated when executing an application that uses cells.  
           [0048]    Furthermore, in the above garbage collection apparatus, a tray indicating an unused cell block newly specified by the scavenging processing may be recognized as an unused tray that does not hold a first type address.  
           [0049]    In addition to the above effects, this construction enables the garbage collection apparatus to recycle trays which no longer need to be used, when a new request for use of cells is received.  
           [0050]    Furthermore, in the above garbage collection apparatus, a value used for the second type address may be limited to within a specific range, the assuming means makes the assumption that data held by a cell is a second type address only when a tray, indicated when (1) the data is within the specific range and (2) the data is hypothetically assumed to be a type two address, is not an unused tray, and the garbage collection apparatus further comprises: detecting means for detecting that a value has been newly assigned to a cell; and prohibiting means for prohibiting, when the newly assigned value is assumed to be a second type address by the assuming means, use of a tray specified by the numerical value by hypothetically assuming that the value is a second type address.  
           [0051]    In addition to the above effects, the garbage collection apparatus having this construction prohibits use of trays corresponding to numerical values which have been newly assigned to a cell, and judges whether a tray specified by the data assigned to a cell is an unused tray when an assumption is made. Consequently, cases in which a numerical value within the specified range for second type addresses is mistakenly assumed to be a second type address can be avoided.  
           [0052]    Furthermore, the above garbage collection apparatus may further comprise: freeing means for freeing, when (1) a specified number of trays that each (a) hold a first type address or (b) are prohibited from being used, cannot be used, and (2) a request for use of a new tray is received, the trays that are prohibited from being used.  
           [0053]    The garbage collection apparatus with this construction, in addition to the above effects, enables trays, about which mistaken assumptions are likely to be made, but which are no longer in use, to be recycled effectively. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0054]    These and other objects, advantages and features of the invention will become apparent from the following description thereof taken in conjunction with the accompanying drawings which illustrate a specific embodiment of the invention. In the drawings:  
         [0055]    [0055]FIG. 1 shows the construction of a heap memory used by the garbage collector in an embodiment of the present invention;  
         [0056]    [0056]FIG. 2 shows an example of content stored in cells forming the heap, and□reference relationships between the cells;  
         [0057]    [0057]FIG. 3 shows an example of cell blocks, each formed from a plurality of cells, and the reference relationships between the cell blocks;  
         [0058]    [0058]FIGS. 4A and 4B illustrate garbage collection performed on a heap in the state shown in FIG. 3;  
         [0059]    [0059]FIG. 5 shows a first flowchart of the scavenging process performed by the garbage collector;  
         [0060]    [0060]FIG. 6 shows a second flowchart of the scavenging process performed by the garbage collector;  
         [0061]    [0061]FIG. 7 shows an outline structure of a reservation system using the garbage collector of the present invention  
         [0062]    [0062]FIG. 8 shows a structure of a reservation database management unit  4  included in the reservation system;  
         [0063]    [0063]FIG. 9 is a flowchart showing processing performed by the application unit  42 ;  
         [0064]    [0064]FIG. 10 is a flowchart showing processing performed by the initialization unit  41 ;  
         [0065]    [0065]FIG. 11 is a flowchart showing processing performed by the cell block allocation unit  441 ;  
         [0066]    [0066]FIG. 12 is a flowchart showing processing performed by the scavenging unit  442  called by the cell block allocation unit  441 ;  
         [0067]    [0067]FIG. 13 shows a first flowchart of processing performed by the compaction unit  443  called by the cell block allocation unit  441 ;  
         [0068]    [0068]FIG. 14 shows a second flowchart of processing performed by the compaction unit  443  called by the cell block allocation unit  441 ;  
         [0069]    [0069]FIG. 15 shows a first flowchart of the processing performed by each of the terminals A 1  to C 3 ;  
         [0070]    [0070]FIG. 16 shows a second flowchart of the processing performed by each of the terminals A 1  to C 3 ;  
         [0071]    [0071]FIG. 17 is a flowchart showing the processing performed by a cell assigning unit  43  called by the terminals A 1  to C 3 ;  
         [0072]    [0072]FIG. 18 shows the condition of cells immediately following the performance of operations I and II in table 2;  
         [0073]    [0073]FIG. 19 shows the condition of cells immediately prior to the processing performed by the scavenging unit  442  at S 34  (see FIG. 12) when an operation IV is performed following an operation III;  
         [0074]    [0074]FIG. 20 shows the condition of cells immediately prior to processing performed by the scavenging unit  442  at S 45 , when the operation IV is performed;  
         [0075]    [0075]FIG. 21 shows the condition of cell immediately following processing performed by the scavenging unit  442  when the operation IV is performed;  
         [0076]    [0076]FIG. 22 shows the condition of cells immediately prior to processing performed by the compaction unit  443  at S 61  (see FIG. 13), when the operation IV is performed;  
         [0077]    [0077]FIG. 23 shows the condition of cells immediately following processing performed by the compaction unit  443 , when operation IV is performed;  
         [0078]    [0078]FIG. 24 is a flowchart showing processing performed by the initialization unit  41  prior to execution performed by the garbage collector of the modification;  
         [0079]    [0079]FIG. 25 is a flowchart showing processing performed by a cell block allocation unit in the garbage collector of the modification;  
         [0080]    [0080]FIG. 26 is a flowchart showing processing performed by a cell assigning unit in the garbage collector of the modification;  
         [0081]    [0081]FIG. 27 shows the construction of a heap memory used by the garbage collector;  
         [0082]    [0082]FIG. 28 shows an example of a cell block composed of a plurality of cells;  
         [0083]    [0083]FIG. 29 shows an example of cell blocks, each formed from a plurality of cells, in a heap memory used by the garbage collector of a first prior art, and the reference relationships between the cell blocks;  
         [0084]    [0084]FIG. 30 shows an example of cell blocks, each formed from a plurality of cells, in a heap memory used by the garbage collector of a second prior art, and the reference relationships between the cell blocks; and  
         [0085]    [0085]FIG. 31 shows an example of cell blocks, each formed from a plurality of cells, in a heap memory used by the garbage collector of a third prior art, and the reference relationships between the cell blocks. 
     
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0086]    The following is a description of the preferred embodiments of the present invention, with reference to the drawings.  
         [0087]    First Embodiment  
         [0088]    The following is a explanation of a garbage collector in a first embodiment of the present invention, with reference to the drawings.  
         [0089]    [0089]FIG. 1 shows the construction of a heap memory (hereafter ‘heap’) used by the garbage collector, and FIG. 2 shows an example of content stored in cells forming the heap, and reference relationships between the cells.  
         [0090]    The heap includes a cell array, and a tray array, as shown in FIG. 1. Each cell holds a numerical value or a handle, and each tray holds a reference. The garbage collector manages the condition of cells using valid references stored in the trays.  
         [0091]    As shown in FIG. 2, references may be valid references indicating cell addresses, and NULL references that do not indicate cell addresses, while handles may be valid handles indicating addresses for trays that store valid references, or NULL handles that do not indicate trays.  
         [0092]    Here, a cell with a valid reference  0  and a cell with a valid reference  4  are shown as holding the valid handle  2 , and indicate a tray with a valid handle  2 , while a cell with a valid reference  7  stores a valid handle  3  and indicates a tray with the valid handle  3 . Similarly, cells with valid references  12 ,  15 , and  17  respectively hold valid handles  1 ,  0 , and  4 , indicating trays with correspondingly numbered valid handles. In FIG. 2, these reference relationships between cells and trays are shown by polygonal lines.  
         [0093]    [0093]FIG. 2 also indicates, using polygonal lines, cells having valid references held by trays. A tray with a valid handle  0  holds a valid reference  3 , one with a valid handle  1  holds a valid reference  4 , one with a valid handle  2  holds a valid reference  7 , one with a valid handle  3  holds a valid reference  8 , and one with a valid handle  4  holds a valid reference  14 , so that each indicates a cell having a corresponding valid reference.  
         [0094]    The garbage collector of the present invention makes assumptions regarding whether the content of a cell is a numerical value or a handle, and whether a given cell block can be traced (reached) from a root cell block, performs scavenging based on the assumption results, and then performs compaction on a heap on which scavenging (relocation of reachable objects) has already been performed, based on the assumptions. This garbage collector is characterized by having the ability to prevent handles from being mistakenly assumed to be numerical values.  
         [0095]    However, although the garbage collector does not mistakenly assume that handles are numerical values, there is still a possibility of it mistakenly assuming numerical values to be handles. For example, in FIG. 2, the curved lines from a cell with a valid reference  9  to a tray with a valid handle  0 , and from a cell with a valid reference  10  to a tray with a valid handle  4  indicate that the garbage collector has mistakenly assumed what are actually numerical references to be handles.  
         [0096]    Suppose that a processor handles a plurality of data memory spaces, and that a single data memory space having a 32-bit address space is occupied by a data segment and an extra segment, cells being allocated to the data segments and trays being allocated to the extra segments. In such a case, the garbage collector checks a tray in the extra segment specified by the value held by a cell, and assumes that the value held by the cell is either a valid handle or a numerical reference, according to whether the tray holds a valid reference or not.  
         [0097]    Alternatively, suppose that the processor handles just one data memory space, in which, for example, addresses 3000 to 12999 are allocated to cells, and addresses 0 to 2999 to trays. In this case, the garbage collector checks whether a value held by a cell corresponds to a tray address, and whether the tray holds a valid reference. If the value corresponds to a tray address, and the tray holds a valid reference, the value held by the cell is assumed to be a valid handle.  
         [0098]    [0098]FIG. 3 shows an example of cell blocks, each formed from a plurality of cells, and the reference relationships between the cell blocks.  
         [0099]    A specific cell block reserved in the heap is known as the root cell block, cells that are not part of any cell block as unused cells, and an area that is formed from a plurality of continuous unused cells as an unused cell area. In addition, trays holding NULL references are known as unused trays, and an area that is formed from a plurality of continuous unused trays as an unused tray area.  
         [0100]    A cell block A holds a valid handle, and the tray indicated by this valid handle holds a valid reference, which indicates a start cell in a cell block B. Here, cell block A is said to ‘reference’ cell block B. The heap includes n cell blocks X 1  to Xn, and each of cell blocks Xi (i=1, 2, . . . , n−1) reference each of cell blocks Xi+1. Here, a ‘trace’ can be performed from cell block X 1  to cell block Xn.  
         [0101]    In FIG. 3, a root cell block references a cell block  4  via a tray with a valid handle  3 , a cell block  3  references a cell block  2  via a tray with a valid handle  1 , a cell block  4  references a cell block  2  via a tray with a valid handle  1 , and a cell block  5  via a tray with a valid handle  4 . These references are shown by polygonal lines. A tray with a valid handle  0  holds a valid reference  1  and references a cell block  1 , but is not referenced by any other cell block.  
         [0102]    A cell with a valid reference  4 , included in the cell block  2 , holds a numerical value 2, but the garbage collector mistakenly assumes this numerical value to be a handle, and this is illustrated by a curved line.  
         [0103]    When a new memory block is required, an application allocates a cell block with the required number of cells from the unused cell area (this operation may also be performed by the garbage collector, as is described later in this specification), and sets the cell block so that a trace can be performed from a root block. This is known as ‘reserving a cell block’.  
         [0104]    As the application is operated it may become impossible for it to reserve cell blocks having the required size in the heap. Here, the garbage collector performs scavenging and compaction, enabling the application to reserve cell blocks of the required size in the heap.  
         [0105]    [0105]FIG. 4 illustrates garbage collection performed on a heap in the state shown in FIG. 3. FIG. 4A shows the result of scavenging performed on the heap shown in FIG. 3, and FIG. 4B shows the result of compaction performed on the heap shown in FIG. 4A.  
         [0106]    In FIG. 4A, the garbage collector updates the content of the tray with the valid handle  0  that is not referenced by any of the cell blocks from a valid reference  1  to a NULL reference. As a result, the tray becomes an unused tray, and the cell block  1  is no longer indicated by the valid handle  0 , and is freed to become part of the unused cell area.  
         [0107]    Cell blocks  2  to  5 , which can be traced from the root cell block, are not freed, and remain allocated. In addition, the trays with valid handles  2 ,  1 ,  3 , and  4 , which are used as references between these cell blocks, are not freed and remain allocated.  
         [0108]    When performing compaction on the heap shown in FIG. 4A, the garbage collector, as shown in FIG. 4B, shifts cell blocks  2  to  5  forward by an amount corresponding to the size of the freed cell block  1 , while preserving references from the root cell block to cell block  4 , from cell block  3  and cell block  4  to cell block  2 , and from cell block  4  to cell block  5 , as well as a mistakenly assumed reference from cell block  2  to cell block  3 . As a result, the unused blocks corresponding to the cell block  1  can be integrated into the subsequent unused cell area.  
         [0109]    When cell blocks are shifted forward in this way, the values of a valid handle  3  held in a cell with a valid reference  0 , a valid handle  1  held in cells with valid references  7  and  9 , and a valid handle  4  held in a cell with a valid reference  11 , as well as that of a numerical value 2 held in a cell with a valid reference  4  are not updated. However, the valid references  8 ,  3 ,  12 , and  6  held in trays with corresponding valid handles are updated respectively to valid references  6 ,  1 ,  10 , and  4 .  
         [0110]    Next, the scavenging performed by the garbage collector in the present embodiment is explained in detail.  
         [0111]    [0111]FIGS. 5 and 6 show a flowchart of the scavenging process performed by the garbage collector.  
         [0112]    The garbage collector set an ‘in use’ flag Fx for a cell block x at 0 (S 1 ), and pushes a reference indicated by a handle held in the root cell block onto the stack (S 2 ). The ‘in use’ flag Fx is set for each cell block to indicate whether that particular cell block can be traced from the root cell block. Here, x=1, 2, . . . , M, M being a number of individual cell blocks.  
         [0113]    The garbage collector pops a reference accumulated in the stack (S 3 ), and sets a start cell of a cell block x indicated by the popped reference as an object cell (S 4 ). Then the garbage collector sets the ‘in use’ flag Fx for cell block x at 1 (S 5 ).  
         [0114]    Next, the garbage collector makes an assumption regarding the content of the object cell (S 6 ), and determines whether the content of the cell is assumed to be a handle (S 7 ). If content of the object cell is assumed to be a handle (S 7 , Yes), the garbage collector pushes a reference indicated by the handle onto the stack (S 8 ), and continues on to the processing of S 9 . If, however, the content of the object cell is not assumed to be a handle (S 7 , No), the garbage collector omits the processing of S 8  and moves to the processing of S 9 .  
         [0115]    At S 9 , the garbage collector determines whether a subsequent cell exists in the same cell block, and if such a cell exists (S 9 , Yes), makes this cell the object cell (S 10 ), and then repeats the processing of S 6  onward. If a subsequent cell does not exist (S 9 , No), the garbage collector determines whether the stack is empty (S 11 ). If the stack is not empty (S 11 , No), the garbage collector repeats the processing of S 3  onward, and if the stack is empty (S 11 , Yes), continues on to the processing of S 12 , in FIG. 6.  
         [0116]    At S 12 , the garbage collector assigns a value 1 to y and determines whether the content of a tray with the handle y is a valid reference (S 13 ). If the content of the tray with the handle y is a valid reference (S 13 , Yes), the garbage collector then determines whether the ‘in use’ flag Fx for the cell block x indicated by the valid reference is 0 (S 14 ). If the ‘in use’ flag Fx is 0 (S 14 , Yes), the garbage collector assigns a NULL reference to the tray with the handle y (S 15 ), and then determines whether y is equal to the number of trays N (S 16 ). If the ‘in use’ flag Fx is not 0 (S 14 , No), the garbage collector omits the processing of S 15 , and moves to S 16 .  
         [0117]    If y is not equal to N (S 16 , No), the garbage collector adds 1 to y (S 17 ), and repeats the processing of S 13  onward. If y is equal to N (S 16 , Yes), the garbage collector ends the processing.  
         [0118]    By means of such a scavenging process, the garbage collector can make assumptions as to whether cells contain handles, as well as specifying cell blocks which can be traced from the root cell block. Then the ‘in use’ flags Fx of the specified cell blocks are set at 1, and all other cell blocks freed to form an unused cell area.  
         [0119]    In the garbage collector of the present embodiment, there is a possibility that cell content that is actually a numerical value will be mistakenly assumed to be a handle when the above scavenging processing is performed. However, since intermediate addresses (handles) are used to specify cells, and the content of the trays specified by these handles is updated when compaction is performed, the actual content of the cells themselves is not updated and compaction can be performed effectively.  
         [0120]    The following is a summary of the particular characteristics of first to third garbage collectors that are examples of the prior art, and of the garbage collector of the present invention.  
                                                                 TABE 1                                   Method of   Time Required       Time   Application           Determining   for   Compaction   Required For   Execution           Cell Content   Scavenging   Execution?   Compaction   Load                                    1st   Reference   Long   Possible   Long   Large       Garbage   Flag       Collector       2nd   Reference   Long   Possible   Short   Large       Garbage   Flag       Collector       3rd   Assumption   Short   Impossible       Small       Garbage       Collector       Invention   Assumption   Short   Possible   Short   Small                  
 
         [0121]    Each 4-byte cell requires, for example, a 1-bit reference flag, but in order to use the heap more effectively, reference flags for eight cells are grouped together. When a value is assigned to a cell during execution of an application, a reference flag indicating whether the cell contains a reference or a numerical value needs to be set, and accessing such reference flags is time-consuming. Furthermore, when scavenging is performed, the garbage collector must check whether the cell value is a reference or a numerical value, and accessing such reference flags is also time-consuming.  
         [0122]    As shown in Table 1, the first and second prior art garbage collectors use reference flags to determine cell content. These garbage collectors use reference flags when exchanging information with an application and refer to reference flags when performing scavenging. As a result, the load placed on the processor by application execution and the load required for scavenging are increased. If a processor having a fixed throughput is used for processing, a greater amount of time will be required to perform this processing.  
         [0123]    In contrast to the first and second prior art garbage collectors, the third prior art garbage collector and the garbage collector of the present invention are conservative garbage collectors that make assumptions when determining the content of cells. If such a garbage collector is used, there is no need to use reference flags when an application is executed, or to refer to reference flags when scavenging is performed. Consequently, the processing load required during both program execution and scavenging is reduced, and processing can be performed in a shorter time.  
         [0124]    The third prior garbage collector is unable to perform compaction due to the fact that mistaken assumption may have been made regarding cell content during scavenging. However, the scavenging performed by the garbage collector of the present invention is such that a conservative garbage collector capable of performing compaction can be realized.  
         [0125]    The following is an explanation of an actual example of the garbage collector in the present invention, realized in a reservation system that reserves seats in response to input from a user terminal.  
         [0126]    [0126]FIG. 7 shows an outline structure of a reservation system using the garbage collector of the present invention, and FIG. 8 shows a structure of a reservation database management unit  4  included in the reservation system.  
         [0127]    The reservation system includes a terminal A 1 , a terminal B 2 , a terminal C 3 , and a reservation database management unit  4 , as shown in FIG. 7. In the reservation system, reservation requests specifying a number of seats required are made to the reservation database management unit  4 , in response to an input specifying a number of seats made by a user of one of terminals A 1 , B 2  and C 3 . The reservation database management unit  4  provisionally reserves two candidate sets of seat numbers with the required number of seats, and sends these two candidates back to the terminal from which the reservation request originated. Once the two candidates are received, a user selects one candidate by making an input into the terminal, and the terminal informs the reservation database management unit  4  of the user selection. The reservation database management unit  4  confirms the reservation of the candidate selected by the user, and ends the reservation process.  
         [0128]    The reservation database management unit  4  includes an initialization unit  41 , an application unit  42 , a cell assigning unit  43 , and a garbage collector  44 . The initialization unit  41  initializes cells used to execute a reservation. The application unit  42  controls overall operations and reserves a number of seats desired by a user. The cell assigning unit  43  assigns values to cells in a cell block. The garbage collector  44  allocates cell blocks in the memory in accordance with requests made by the application unit  42  and performs garbage collection when required. The garbage collector  44  includes a cell block allocating unit  441  that allocates cell blocks, a scavenging unit  442  that performs the scavenging described above, and a compaction unit  443  that performs the compaction described above.  
         [0129]    The application unit  42 , initialization unit  41 , cell block allocation unit  441 , scavenging unit  442 , compaction unit  443 , terminals A 1  to C 3 , and cell assigning unit  43  perform the processing shown in FIGS.  9  to  17 . Seat reservation is executed while the garbage collector  44  reserves memory required by the application unit  42 , and performs scavenging and compaction as necessary.  
         [0130]    Cell blocks used when executing the processing shown in FIGS.  9  to  17  are sectional arrays within the cell array, a reference address for a start cell being x, and required cell block length n. These have the following structure.  
         [0131]    C[x]=start reference for a next cell block  
         [0132]    C[x+1]=n(=required cell block length)  
         [0133]    C[x+2]=‘in use’ flag or work used in compaction  
         [0134]    C[x+3] to C[x+2+n]=cell block content that can be freely used by the application.  
         [0135]    Here, a root cell block contains the following cells. The relevant values are assigned by the initialization unit  41 .  
         [0136]    C[1]=5  
         [0137]    C[2]=1  
         [0138]    C[3]=NULL  
         [0139]    C[4]=NULL  
         [0140]    When a reservation is executed by the reservation system, the garbage collector  44  performs operations that are independent of the operation of the application, apart from allocating cell blocks in response to requests from the application. The garbage collector  44  performs scavenging and compaction in response to requests from the application. In addition, the garbage collector  44  performs processing only on a cell block that has been identified as having the structure described above. The scavenging unit  442  does not determine in advance whether the content of a cell block is a numerical value or a handle, but makes assumptions regarding cell content.  
         [0141]    Thus, the garbage collector  44  does not know the exact content of cell blocks used by the application, and the application uses a system cell block and candidate cell blocks having the following data structure in order to execute reservations.  
         [0142]    System Block (start cell reference is x0)  
         [0143]    C[x0] to C[x0+2]=values corresponding to the above C[x] to C[x+2] 
         [0144]    C[x0+3]=handle of a cell storing a reference to a candidate cell block for terminal A 1   
         [0145]    C[x0+4]=handle of a cell storing a reference to a candidate cell block for terminal B 2   
         [0146]    C[x0+5]=handle of a cell storing a reference to a candidate cell block for terminal C 3  Candidate Cell Block for a Terminal t (=A, B, C)  
         [0147]    C[xt] to C[xt+2]=values corresponding to the above C[x] to C[x+2] 
         [0148]    C[xt+3]=number of reserved seats  
         [0149]    C[xt+4] to C[xt+3+number of reserved seats]=seat numbers of seats provisionally reserved as a candidate 1  
         [0150]    C[xt+4+number of reserved seats] to C[xt+3+2□number of reserved seats]=seat numbers of seats provisionally reserved as a candidate 2  
         [0151]    The following numerical references are used in the flowcharts and related explanation.  
         [0152]    C: cell array  
         [0153]    N: number of cells (size of cell array)  
         [0154]    C[1] to C[N]: cell  
         [0155]    T: tray array  
         [0156]    M: number of trays (size of the tray array)  
         [0157]    T[1] to T[M]: tray  
         [0158]    NULL: numerical value 0  
         [0159]    U: start reference of an unused cell block  
         [0160]    W: work performed at compaction  
         [0161]    S: reference stack  
         [0162]    [0162]FIG. 9 is a flowchart showing processing performed by the application unit  42 , and FIG. 10 is a flowchart showing processing performed by the initialization unit  41 .  
         [0163]    In the processing shown in FIG. 9, the application unit  42  calls the initialization unit  41 , initializes a cell block in the memory, and sets a root cell block (S 21 ). Next, the application unit  42  sets a required number of cells n at 3, and calls the cell block allocation unit  441 . The application unit  41  assigns a handle h obtained as a result of processing performed by the cell block allocation unit  441  to C[4], thereby reserving the system block (S 22 ).  
         [0164]    Then, the application unit  42  assigns 1 to s (S 23 ), assigns s to a variable k to be used in processing, and calls a terminal s (s=1, 2, 3) (S 24 ). The terminal s responds to a reservation request made by a user and performs provisional and confirmed seat reservation in turn by performing processing such as cell block allocation and assigning values to cell blocks, with garbage collection being performed as necessary. This process is explained later in this specification in more detail, with reference to FIGS. 15 and 16. Once the terminal s has been called, the application unit  44  adds 1 to s (S 25 ). The application unit  44  then repeats the processing from S 23  (S 26 , Yes) or from S 24  (S 26 , No), depending on whether the value of s is greater than or smaller than 3, and calls terminals A 1 , B 2  and C 3  in turn.  
         [0165]    In the processing of S 21 , the application unit  42  calls the initialization unit  41 . Here, as shown in FIG. 10, the initialization unit  41  assigns a value 1 to x (S 2101 ), and NULL value to C[x] (S 2102 ). Then, the initialization unit  41  determines whether x is equal to a number of cells N (S 2103 ). If x is not equal to N (S 2103 , No), the initialization unit  41  adds 1 to x (S 2104 ), and repeats the processing from S 2102  onward. If x is equal to N (S 2103 , Yes), the initialization unit  41  continues on to S 2105 . The processing of S 2101  to S 2104  is performed to initialize all of the cells C[1] to C[N] by setting them at NULL.  
         [0166]    Following this, the initialization unit  41 , at S 2105 , assigns 1 to x once again, and assigns NULL to T[x] (S 2106 ). Then, the initialization unit  41  determines whether x is equal to a number of trays M (S 2107 ). If x is not equal to M (S 2107 , No), the initialization unit  41  adds 1 to x (S 2108 ) and repeats the processing of S 2106  onward. If x is equal to M (S 2107 , Yes), the initialization unit  41  continues on to S 2109 . The processing of steps S 2105  to S 2108  is performed to initialize all of the trays T[1] to T[M] by setting them at NULL.  
         [0167]    At S 2109 , the initialization unit  41  sets a root cell block by assigning  5  to C[1] and 1 to C[2], and assigns 5 to a start reference U for an unused cell block (S 2109 ). This completes the processing performed by the initialization unit  41 . Following this, the processing of S 22 , in which the cell block allocation unit  441  is called by the application unit  42 , is performed.  
         [0168]    [0168]FIG. 11 is a flowchart showing processing performed by the cell block allocation unit  441 , FIG. 12 is a flowchart showing processing performed by the scavenging unit  442  called by the cell block allocation unit  441 , and FIGS. 13 and 14 show a flowchart of processing performed by the compaction unit  443  called by the cell block allocation unit  441 .  
         [0169]    In the processing shown in FIG. 11, the cell block allocation unit  441  first determines whether a number of required cells is (N−U−3) or less, in other words whether the required number of cells can be reserved in the memory (S 2201 ). If n is (N−U−3) or less (S 2201 , Yes), the initialization unit  41  continues on to S 2205 , but if n is more than (N−U−3) (S 2201 , No), the cell block allocation unit  441  calls the scavenging unit  442  (that performs the processing shown in FIG. 12) and the compaction unit  442  in turn (S 2202 , S 2203 ), and determines once again whether n is (N−U−3) or less (S 2204 ). If n is more than (N−U−3) (S 2204 , No), the process is brought to an abnormal end (ABEND) as there are an insufficient number of cells available for use. If n is no more than (N−U−3)(S 2204 , Yes) the initialization unit  41  moves to S 2205 .  
         [0170]    At S 2205 , the cell block allocation unit  441  assigns a value 1 to h, and determines whether h is no more than a number of trays M (S 2206 ). If h is more than M (S 2206 , No), the process is brought to an abnormal end as there are an insufficient number of trays available for use. If h is no more than M (S 2206 , Yes), the cell block allocation unit  441  determines whether T[h] is NULL (S 2207 ). If T[h] is not NULL (S 2207 , No), the cell block allocation unit  441  adds 1 to h (S 2208 ) and repeats the processing of S 2206  onward. If T[h] is NULL (S 2207 , Yes), the initialization unit  41  continues on to step S 2209 .  
         [0171]    If a handle h corresponding to a tray that has not been used in the processing of S 2205  to S 2208  is specified, a start reference U for an unused cell block is assigned to T[h], a value (U+n+3) to C[U], and a value n to C[U+1], before (n+3) is added to U (S 2209 ), and the processing performed by the cell block allocation unit  441  ends.  
         [0172]    In this way, the cell block allocation unit  441  reserves a system cell block in response to a call from the application unit  42  (S 22 ) that specifies a required number of cells  3 . Then, the cell block allocation unit  441  outputs a handle h specifying a tray that stores a start reference for the system block, and reserves a candidate cell block in response to a call from one of terminals A 1  to C 3  (S 2411 ) that sets a required number of cells n at (2□number of seats+1). Next, the cell block allocation unit  441  outputs a handle h specifying a tray that stores a start reference for the newly reserved candidate cell block.  
         [0173]    In the processing of S 2202  the cell block allocation unit  441  calls the scavenging unit  442 . Here, as shown in FIG. 12, the scavenging unit  442  first assigns a value 1 to x (S 31 ), and determines whether C[x] is NULL (S 32 ). If C[x] is not NULL (S 32 , No), the scavenging unit  442  assigns 0 to C[x+ 2 ], updates x to the value shown by C[x] (S 3 ), and repeats the processing from S 32  onward. If C[x] is NULL (S 32 , Yes), processing moves to step S 34 . Here, C[x+ 2 ] is used as an ‘in use’ flag, and the processing of S 31  to S 33  sets the ‘in use’ flag for in use cell blocks at an initial value of 0.  
         [0174]    At S 34 , the scavenging unit  442  pushes a value 1 onto the reference stack S, thereby determining whether the reference stack S is empty (S 35 ). If the reference stack S is not empty (S 35 , No), a reference stacked in S is popped to r (S 36 ), and the scavenging unit  442  determines whether r is a NULL value (S 37 ). If r is NULL (S 37 , Yes), the scavenging unit  442  repeats the processing of S 35  onward. If r is not NULL (S 37 , No) the scavenging unit  442  determines whether C[r+2] is 0 (S 38 ) (this is to prevent the structure of the cell block causing an infinite loop to be formed by the processing from S 35  onward).  
         [0175]    If C[r+2] is not 0 (S 38 , No), the scavenging unit  442  repeats the processing from S 35  onward, and if C[r+2] is 0 (S 38 , Yes), sets the ‘in use’ flag for in use cell blocks at 1 by assigning a numerical value 1 to C[r+2], and assigns a value 0 to x (S 39 ).  
         [0176]    Next, the scavenging unit  442  determines whether x is smaller than a value C[r+1], in other words whether the following processing has been performed on all the cells included in the cell block (S 40 ). If x is not smaller than C[r+1] (S 40 , No), the scavenging unit  442  moves to the processing of S 35  to perform processing on the next cell block. If x is smaller than C[r+1], (S 40 , Yes), the scavenging unit  442  then determines whether the value of C[r+3+x] is in a range of 1 to M inclusive (S 41 ), and whether T[C[r+3+x]] is NULL (S 42 ). Only when C[r+3+x] is in a range of 1 to M inclusive (S 41 , Yes), and T[C[r+3+x]] is not NULL (S 42 , No), is T[C[r+3+x]] pushed onto the reference stack S (S 43 ). Following this, the scavenging unit  442  updates x by adding 1 (S 44 ), and repeats the processing of S 40  onward.  
         [0177]    After emptying the reference stack S by tracing the cell blocks in order (S 35 , Yes), the scavenging unit  442  once more assigns a value 1 to x (S 45 ), and determines whether T[x] is NULL (S 46 ), and whether C[T[x]+2] is 1, in other words whether the ‘in use’ flag for a cell block indicated by T[x] is 1 (S 47 ).  
         [0178]    If T[x] is not NULL (S 46 , No), and C[T[x]+2] is not 1 (S 47 , No), the scavenging unit  442  assigns a NULL value to T[x] (S 48 ), and adds 1 to x (S 49 ). If T[x] is NULL (S 46 , Yes), or C[T[x]+2] is 1 (S 47 , Yes), the processing of S 48  is omitted and S 49  performed. The scavenging unit  442  determines whether x is N or less (S 50 ). If x is N or less (S 50 , Yes), the scavenging unit  442  repeats the processing from S 46 , and if x is more than N (S 50 , No), the processing performed by the scavenging unit  442  ends. Following this, at S 2203 , the cell block allocation unit  441  calls the compaction unit  443  (see FIG. 11).  
         [0179]    The processing performed by the scavenging unit  442  in the above S 41  and S 42  is for making an assumption as to whether a handle or a numerical value is held in a cell block. In other words, when the value held by the cell block is a value that may be taken to be a valid handle, and the tray indicated by this value does not hold a NULL value, the scavenging unit  442  assumes that this value is a handle. Following this assumption, at S 43 , the scavenging unit  442  pushes the reference held in the tray indicated by the value onto the reference stack S, and assumes that the cell block indicated by this reference is in use. At S 45  to S 50 , the scavenging unit  442  assigns a NULL value to a tray indicating a cell block that is not in use, and this tray becomes an unused tray. The processing of S 45  to S 50  enables trays to be recycled effectively.  
         [0180]    [0180]FIGS. 13 and 14 show processing performed by the compaction unit  443 . First, the compaction unit  443  assigns a value 1 to work W and U (S 51 ). Then, the compaction unit  443  determines whether C[U+2] is 1, in other words whether an ‘in use’ flag is 1 (S 52 ). If C[U+2] is 1, the compaction unit  443  assigns W to C[U+2], and adds a value to W. If, however, C[U+2] is not 1, the compaction unit  443  updates U by assigning the value C[U] to U, without updating the values of C[U+2] and W (S 54 ), and then determines whether U is a NULL value (S 55 ). If U is NULL, processing continues on to S 56 . The processing performed by the compaction unit  443  in S 51  to S 55  enables a reference for a start cell following shifting of the cell blocks to be calculated, and specified work for each cell block to be stored.  
         [0181]    At S 56 , the compaction unit  443  assigns a value 1 to x, and determines whether T[x] is a NULL value (S 57 ). If T[x] is not NULL (S 57 , No), the compaction unit  443  assigns a value C[T[x]+2] to T[x]. If T[x] is NULL (S 57 , Yes), the value of T[x] is not changed. Following this, the compaction unit  443  determines whether x is equal to a number of trays M (S 59 ). If x is not equal to M (S 59 , No), the compaction unit  443  adds 1 to x (S 60 ), and repeats the processing of S 57  onward. If x is equal to M (S 59 , Yes), the compaction unit  443  continues on to S 61 . The processing performed by the compaction unit  443  in S 56  to S 60  enables all of trays T[1] to T[M] to be updated so as to indicate a reference for a start cell following shifting of cell blocks.  
         [0182]    At S 61 , the compaction unit  443  assigns a value 1 to U. Next, the compaction unit  443  determines whether a value of C[U+2] is 0, in other words whether C[U+2] indicates that the cell block is unused (S 62 ).  
         [0183]    If the value of C[U+2] is not 0 (S 62 , No), the compaction unit  443  assigns C[U+2]+C[U+1]+3 to C[C[U+2]] (S 63 ). Then, the compaction unit  443  copies the content of C[U+1] through C[U+C[U+1]+2] to each of C[C[U+2]+1] through C[U+2]+C[U+1]+2] respectively (S 64 ), and continues to the processing of S 65 . If the value of C[U+2] is 0 (S 62 , Yes), the compaction unit  443  continues to S 65  without performing the processing of S 63  and S 64 .  
         [0184]    At S 65 , the compaction unit  443  updates U by assigning a value C[U], and determines whether U is a NULL value (S 66 ). If U is not NULL (S 66 , No), the compaction unit  443  repeats the processing of S 62  onward. If U is NULL, however (S 66 , Yes), the compaction unit  443  continues on to the processing of S 67 . The processing of S 61  to S 66  performed by the compaction unit  443  enables actual shifting of cells to be performed.  
         [0185]    At S 67 , the compaction unit  443  assigns a value W to x, and a NULL value to C[x] (S 68 ), and determines whether x is equal to a number of cells N (S 69 ). If x is not equal to N (S 69 , No), the compaction unit  443  updates x by adding 1 (S 70 ). If x is equal to N (S 69 , Yes), the compaction unit  443  ends processing, and processing performed by the cell block allocation unit  441  from S 2204  onward (see FIG. 11) can be performed. The processing of S 67  to S 69  performed by the compaction unit  443  enables a NULL value to be assigned to cells with references from W onward.  
         [0186]    The processing performed by the compaction unit  443  enables those cell blocks that the scavenging unit  442  assumes to be unused to be integrated into the unused cell area.  
         [0187]    As was previously explained, the application unit  42  calls the terminals A 1  to C 3 , as shown in S 24  of FIG. 9.  
         [0188]    [0188]FIGS. 15 and 16 show a flowchart of the processing performed by each of the terminals A 1  to C 3 , and FIG. 17 is a flowchart showing the processing performed by a cell assigning unit  43  called by the terminals A 1  to C 3 .  
         [0189]    A terminal s determines whether a new reservation request has been received from a user (S 2401 ).  
         [0190]    If a new reservation request has been received (S 2401 , Yes), the terminal s determines whether C[T[C[4]]+2+k] is a NULL value (S 2407 ). If C[T[C[4]]+2+k] is a NULL value (S 2407 , Yes), the terminal s continues on to the processing of S 2410 . If C[T[C[4]]+2+k] is a not a NULL value, however (S 2407 , No), the terminal s cancels a provisional reservation held in a candidate cell block indicated by C[T[C[4]]+2+k] (S 2408 ), assigns a NULL value to C[T[C[4]]+2+k] (S 2409 ), and then continues on to the processing of S 2410 .  
         [0191]    At S 2410 , the terminal s receives a user input specifying a number of seats and assigns the input value to x. Then, the terminal s calls the cell block allocation unit  441 , inputting a required number of cells 2□x+1 (S 2411 ). Then, the processing shown in FIG. 11 is performed by the cell block allocation unit  441 , reserving a cell block corresponding to a candidate cell block. Following this, the terminal s calls the cell assigning unit  43  twice, each time transmitting different input (S 2412 , S 2413 ), and assigns values to cells corresponding to the system cell block and the candidate cell block.  
         [0192]    Following this, the terminal s performs a search of a reservation database based on the number of reserved seats x, provisionally reserves two candidates, and assigns the two candidates to the candidate cell block indicated by a handle h (S 2414 ). Then, the terminal s displays the two candidates (S 2415 ), and ends processing.  
         [0193]    If a new reservation request is not received at S 2401 , the terminal s determines whether one of the two candidates has been selected by the user (S 2402 ). If a candidate has not been selected (S 2402 , No), the terminal s ends processing. If a candidate has been selected, however (S 2402 , Yes), the terminal s continues on to the processing of S 2403 .  
         [0194]    At S 2403 , the terminal s assigns a selection number specifying one of the candidates to x, and the candidate, in the candidate cell block, that corresponds to the selection number x is confirmed as the actual reservation (S 2404 ). Then, the terminal s assigns a NULL value to C[T[C[4]]+2+k], freeing cells in the system cell block indicating the candidate cell block for which a reservation has been confirmed (S 2405 ).  
         [0195]    Next, the terminal s displays a message indicating that confirmation of the reservation has been completed (S 2406 ), and ends processing.  
         [0196]    Before the cell assigning unit  43  is called in S 2412  and S 2413 , it performs the following processing. First, the cell assigning unit  43  assigns a handle h indicating a start reference for a cell block to n, an offset value for a cell to which a value is to be assigned to m, and a value to be assigned to the cell to v. In FIG. 17, the cell assigning unit  43  first determines whether T[n] is a NULL value (S 71 ) and whether m is at least 0 but less than C[T[n]+1] (S 72 ). If T[n] is NULL (S 71 , Yes), the cell assigning unit  43  ends processing on the assumption that the handle is abnormal, and if m is not at least 0 but less than C[T[n]+1] (S 72 , No), ends processing on the assumption that the offset value is abnormal.  
         [0197]    If T[n] is not NULL (S 71 , No), and m is at least 0 but less than C[T[n]+1] (S 72 , Yes), the cell assigning unit  43  assigns the value v to C[T[n]+3+m] (S 73 ), and ends processing.  
         [0198]    When, at S 2411 , the terminal s calls the cell block allocation unit  441  and a candidate cell block is reserved in the memory, the scavenging unit  442  and the compaction unit  443  in the garbage collector  44  of the present invention (see FIG. 8) perform scavenging and compaction as required, simultaneous with reservation of the system cell block.  
         [0199]    Suppose that a number of cells is  50 , a number of trays is  4  and user operations of terminals A 1  to C 3  take place as shown in Table 2. In this case, the processing performed by the reservation system shown in FIGS.  9  to  16  will create the changes to cells in the memory shown in FIGS.  18  to  23 .  
                                     TABLE 2                                   User Operation                                        Operation I   Reservation for 9 seats from Terminal A           Operation II   Reservation for 4 seats from Terminal B           Operation III   Completion of Reservation for Terminal A           Operation IV   Reservation for 10 seats from Terminal C                      
 
         [0200]    [0200]FIG. 18 shows the condition of cells immediately following the performance of operations I and II in table 2. FIG. 19 shows the condition of cells immediately prior to the processing performed by the scavenging unit  442  at S 34  (see FIG. 12) when an operation IV is performed following an operation III. FIG. 20 shows the condition of cells immediately prior to processing performed by the scavenging unit  442  at S 45 , when the operation IV is performed. FIG. 21 shows the condition of cell immediately following processing performed by the scavenging unit  442  when the operation IV is performed. FIG. 22 shows the condition of cells immediately prior to processing performed by the compaction unit  443  at S 61  (see FIG. 13), when the operation IV is performed. FIG. 23 shows the condition of cells immediately following processing performed by the compaction unit  443 , when operation IV is performed.  
         [0201]    In FIG. 18, the terminal A 1  makes a reservation request for  9  seats using the operation I, and the terminal B 2  makes a reservation request for  4  seats using the operation II. Immediately after these requests are made, cells 1 to 44 of the 50 cells in the memory managed by the garbage collector  44  are in use.  
         [0202]    Next, once the terminal A 1  selects a candidate, a reference  8  in the system cell block is changed to a NULL value in accordance with this. Then, if the terminal C 3  makes a reservation request for 10 seats using the operation IV, the required number of cells 15 (=2□x+1=2□10+1) is more than 2 (=N−U−3=50−45−3). Consequently, the garbage collector  44  determines that scavenging and compaction need to be performed (this corresponds to FIG. 11, S 2201 , No).  
         [0203]    In the processing performed by the scavenging unit  442  until S 34  (see FIG. 12), ‘in use’ flags for the root cell block, the system cell block, and the candidate cell blocks for the terminals A 1  and B 2  are initialized by being set at 0. Here, the NULL value that initializes cells is 0, so there is no change in the value of the ‘in use’ flags.  
         [0204]    Here, the garbage collector  44  (see FIG. 8) cannot ascertain in advance whether a value held in a cell C[4] in the root cell block, values held in cells C[8] to C[10] in the system cell block, values held in cells C[14] to C[32] in the candidate cell block for the terminal A 1 , and values held in cells C[36] to C[44] in the candidate cell block for the terminal B 2  are numerical values or handles. Consequently, in the processing of S 41  and S 42 , the garbage collector  44  assumes cell values to be either numerical values or handles.  
         [0205]    A value 1 held by the cell C[4] in the root cell block and a value 3 held by a cell B[9] in the system cell block are within the possible range for valid handles, and the values 5 and 33 held in the trays indicated by these handles are not NULL values (0). Therefore, the garbage collector  44  assumes that the cells C[4] and C[9] both hold handles, and furthermore that the system cell block and the candidate cell block for the terminal B 2  indicated by the values that are held in the trays indicated by these handles are in use.  
         [0206]    On the other hand, a value 0 held by a cell C[8] and a cell C[10] in the system cell block, and a value 9 held by a cell [14] in the candidate cell block for the terminal A 1  are not within the possible range for valid handles. A value 4 held by a cell C[36] in the candidate block for the terminal B 2  is within the possible for valid handles, but the tray indicated by this handle holds a value 0. Therefore, the garbage collector  44  assumes that the cells C[8], C[10], C[14], and C[36] hold numerical values. The garbage collector  44  makes similar assumptions about the cells C[15] to C[32] in the candidate block for the terminal A 1  and about the cells C[37] to C[44] in the candidate block for the terminal B 2 .  
         [0207]    As a result of these assumptions, the garbage collector  44  sets ‘in use’ flags for cell blocks assumed to be in use, in other words cells C[3], C[7], and C[35], at 1, as shown in FIG. 20. Following this, processing performed by the garbage collector  44  from S 45  onward sets a NULL value in a tray T[2] that indicates a cell block that has been assumed to be unused, and the condition of the cells is as shown in FIG. 21.  
         [0208]    The scavenging unit  442  makes inferences about the reference relationships between cell blocks according to whether a cell value is assumed to be a numerical value or a handle. Following this, the compaction unit  443  places the cells in the condition shown in FIG. 22 and then in that shown in FIG. 23, by reserving an area for storing seat numbers and numbers of seats for a number of seats  10  requested in an operation IV.  
         [0209]    In this way, the reservation system is divided into components directly concerned with the operation of the application, that is seat reservation, and the garbage collector  44  that reserves and frees memory according to request from the application. Here, the garbage collector  44  operates independently of the other components. Since the garbage collector  44  performs scavenging while assuming whether cell contents are numerical values or handles, there is no need to reserve memory for reference flags and the like. Consequently, this prevents an excessive processing load being placed on the processor when the application is executed, as well as enabling high speed compaction to be performed.  
         [0210]    The following is an explanation of a modification of the garbage collector  44 . The garbage collector in this modification sets a ‘use prohibited’ flag for each tray, and allocates cell blocks with reference to these ‘use prohibited’ flags.  
         [0211]    [0211]FIG. 24 is a flowchart showing processing performed by the initialization unit  41  prior to execution performed by the garbage collector of the modification. FIG. 25 is a flowchart showing processing performed by a cell block allocation unit in the garbage collector of the modification. FIG. 26 is a flowchart showing processing performed by a cell assigning unit in the garbage collector of the modification.  
         [0212]    The initialization unit  41  in the reservation system performs processing as shown in FIG. 24, S 3106 , initializing a tray T[x] by setting a NULL value, and a ‘use prohibited’ flag D[x] corresponding to the tray T[x] by setting a value of 0.  
         [0213]    In processing performed by a cell assigning unit in the garbage collector of the modification, when a value assigned to cell to be used is within the possible range for valid handles, and the tray corresponding to the handle holds a NULL value, use of the tray is prohibited, so a value of 1 is assigned to the ‘use prohibited’ flag D[x] for this tray, as shown in S 3074  and S 3075  in FIG. 26.  
         [0214]    Furthermore, the cell assigning unit, as shown in the processing of S 3207  in FIG. 25, specifies a handle h for a newly allocated cell block to trays which hold a NULL value and have a ‘use prohibited’ flag D[x] set at 0.  
         [0215]    If h is more than a number of trays M (S 3206 , No), the cell block allocation unit, as shown in the processing of S 3210  to S 3215 , cancels the prohibition of the use of all trays with ‘use prohibited’ flags set at 0, and repeats the processing of S 3205  onward.  
         [0216]    First, the cell block allocation unit assigns a value 0 to a work flag f, and a value 1 to i (S 3210 ), and determines whether a ‘use prohibited’ flag D[i] corresponding to a tray T[i] is 1 (S 3211 ). If D[i] is 1 (S 3211 , Yes), the cell block allocation unit assigns a value 1 to f and a value 0 to D[i] (S 3212 ). On the other hand, if D[i] is not 1 (S 3211 , No), the processing of S 3212  is not performed.  
         [0217]    Following this, the cell block allocation unit determines whether i is equal to a number of trays M (S 3213 ). If i is not equal to M (S 3213 , No), the cell block allocation unit adds 1 to i, and repeats the processing of S 3211  onward. If i is equal to M (S 3213 , Yes), the cell block allocation unit determines whether f is 1 (S 3215 ).  
         [0218]    If f is not 1 (S 3215 , No), the cell block allocation unit brings processing to an abnormal end due to there being insufficient trays. If f is 1 (S 3215 , Yes), the cell block allocation unit continues on to the processing of S 3205 . In subsequent processing, the cell block allocation unit specifies a handle h that corresponds to a newly allocated cell block for a tray that holds a NULL value, and also has a ‘use prohibited’ flag that has been changed to 0.  
         [0219]    Here, even if a numerical value is mistakenly assumed to be a handle in subsequent scavenging processing, use of the tray corresponding to this value has been prohibited, and the cell block allocation unit has performed the above described processing. As a result, a handle h corresponding to a newly allocated cell block can only be specified for a tray that holds a NULL value and has a ‘use prohibited’ flag set at 0. This ensures that assumptions made regarding cell content by the scavenging unit can be made with greater veracity.  
         [0220]    The scavenging unit assumes that a cell holds a handle when a value contained in the cell is within the available range for handles and, if the value is considered to be a handle, the tray specified by the handle does not hold a NULL value. When a numerical value assigned to a cell is within the available range for handles, but a tray specified, if this value is considered to be a handle, holds a NULL value, the tray concerned has a ‘use prohibited’ flag set at 1. This means that use of the tray is prohibited, and it continues to hold a NULL value. Consequently, cases in which a numerical value within the available range for handles is mistakenly assumed to be a handle can be avoided, and delays in freeing cells can also be avoided.  
         [0221]    Furthermore, when no trays are available for use, prohibitions on tray use can be lifted by resetting the ‘use prohibited’ flags for the trays, thus preventing delays in freeing cells that are not in use, as well as enabling trays to be used more effectively.