JP4139613B2 - Data processing method - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to data processing of a system having a data structure in which a plurality of objects are associated with each other by a pointer, and a plurality of processes for referencing, updating, inserting and deleting objects operate in parallel.
[0002]
[Prior art]
(Prior art 1)
A data management system having a function of accessing data at high speed by the index according to the present invention shall provide the following four functions as a basic data access method;
(1) Reference function: Reference data related to the specified key value
(2) Insert function: Insert specified key value and specified data related to it
(3) Delete function: Delete specified key value and related data
(4) Update function: Updates the data related to the specified key value to the specified data.
A plurality of these functions are requested to be processed in parallel. Hereinafter, processing methods for realizing the respective functions are referred to as reference processing, insertion processing, deletion processing, and update processing.
[0003]
A conventional technique for realizing these functions will be described with reference to FIGS.
An example of the data structure is shown in FIGS. An object group T composed of three objects A, B and C is shown. An object is a unit of data, and an area is secured and released on an object basis. One data is stored in one object.
[0004]
It is assumed that the object B stores a key value 10 and related data. Similarly, it is assumed that the key value 20 and data related thereto are stored in the object C. The object A includes a key held by the object B (ie, key value 10), storage position information of the object B (hereinafter referred to as a pointer), a key held by the object C (ie, the key value 20), and a pointer of the object C. Stored.
[0005]
Here, a method of realizing the above four functions will be described. In order to enable a plurality of processes to execute the above functions in parallel, it is necessary to set / release a lock. As for the lock, for example, “Gray, J., Reuter, A., TRANSACTION PROCESSING: CONCEPTS AND TECHNIQUES, Morgan Kaufmann Publishers, Inc., 1993, p449-484” is described. Here, the locks in the S, X, IS, and IX modes described in the above-mentioned document are used. S mode locks can be executed in parallel with S and IS mode locks, X mode cannot be executed in parallel with all mode locks, IS mode locks can be executed in parallel with S, IS and IX mode locks IX mode locks can be executed in parallel with IS and IX mode locks. The lock setting policy is that the IS mode lock is set for the object group T for the reference processing, the IX mode lock is set for the object group T for the insertion, deletion and update processing, and then the object to be accessed is referenced. In this case, the lock is set hierarchically such that the lock is set in the S mode if it is to be performed, and the lock is set in the X mode if there is a possibility of updating. That is, after setting a lock on an object group, a lock is set on a specific object.
[0006]
As a resource name for setting a lock for an object group, a name that is commonly known by each process is specified. In addition, when a lock is set for an object, a resource name corresponding to the storage position of the object (a resource name is used as position information where the object is stored, for example, a pointer value) is specified. That is, if the storage position is known, the lock can be set on the object. In addition, it is assumed that the storage position of the object (object A in FIG. 1) serving as the base point in the object group is known by all the processes, and the storage position does not move.
[0007]
A time chart of each process is shown in FIG. The time in the time chart flows from left to right. A line segment indicated by black circles at both ends represents a period during which the object shown on the left side of the line segment is locked, the lock mode is indicated above the line segment, and processing is indicated below the line segment. A line segment indicated by white circles at both ends indicates that the object shown on the left side of the line segment is being accessed (without setting a lock), and processing is shown below the line segment. FIG. 2A shows a flowchart of the reference process. Here, an example is shown in which an object having a key value of 10 is referred to. FIG. 2B shows a flowchart of the insertion process. Here, an example in which an object having a key value of 30 is inserted into the group T is shown. FIG. 2C shows a flowchart of the deletion process. Here, an example of deleting an object having a key value of 20 is shown. FIG. 2D shows a flowchart of the update process. Here, an example in which an object having a key value of 10 is updated is shown.
[0008]
In order to show the situation in parallel processing, a case will be described in which the insertion process of the key value 30 and the deletion process of the key value 20 are operating almost simultaneously. The insertion process 202 first sets a lock for the object group T in the IX mode. An object area for storing new data is secured (referred to as object D), and a key value 30 and related data are set in the area. On the other hand, the deletion process 203 similarly sets a lock on the object group T in the IX mode, but this lock can be executed in parallel even if it conflicts with IX in the insertion process, and one of them does not wait. . Next, both the insertion process 202 and the deletion process 203 are processes for setting the X mode lock for the object A, and the other is kept waiting until the process that has previously set the lock releases the lock.
[0009]
First, a case where the deletion process 203 succeeds in setting a lock prior to the insertion process 202 will be described. The insertion process 202 is waited until the deletion process 203 unlocks the object A. The deletion process 203 accesses the object A, acquires a pointer to the object B corresponding to the key value 20, sets a lock in the X mode for the object C, and sets the key value 20 and the object C in the object A to the lock. The pointer is deleted (hereinafter referred to as “detaching the pointer”), the lock on the object A is released (at this time, the waiting for the insertion process 202 is released), and the object area storing the object C is released. The object C is unlocked, and finally the object group T is unlocked. This state is shown at 102 in FIG.
[0010]
Upon receiving the unlocking of the object A by the deleting process 203, the inserting process 202 succeeds in setting the lock on the object A. In the insertion process 202, the object A is accessed, the storage position of the key value 30 and the object D is set in the object A, the lock set in the object A is released, and the lock set in the object group T is released. This state is shown in FIGS.
[0011]
On the other hand, if the insertion process 202 succeeds in setting the lock prior to the deletion process 203, the deletion process 203 waits until the insertion process 202 unlocks the object A. The insertion process 202 performs the same process as described above, resulting in the state shown in FIGS. Thereafter, the deletion process 203 is executed, and the state shown in FIGS.
[0012]
The reference process (key value 10) is shown in FIGS. 2 and 201, and the update process (key value 10) is shown in FIGS. The reason why the lock of the object B is set before the lock on the object A is released in the reference process 201 and the update process 204 is to prevent a malfunction when the deletion process of the object B is operating in parallel. It is. In other words, if the lock of the object B is set after the lock on the object A is released, the area of the object B can be released by the deletion process during that time, and the released area can be reused for another purpose. There is a possibility that the data set and assigned is regarded as the data of the object B and malfunctions.
[0013]
Further, as a simpler method, there is a method of setting an S mode lock on the object group T in the case of reference processing, and setting an X mode lock on the object group T in the case of insertion, deletion and update processing. Since this method cannot execute parallel processing except for reference processing, resources such as disks and processors cannot be used more effectively than in the above example, and throughput and response time are reduced.
[0014]
As described above, in the related art 1, the object A is locked on the object A while the object A is locked. This has the advantage that the area of the object deleted by the object deletion process can be released, but has a characteristic that the parallel execution performance is slightly low.
[0015]
(Prior art 2)
The B-tree index in the DB management system has a data structure that is an extension of prior art 1. As an example, FIGS. 7 and 701 show a three-stage B-tree index composed of seven pages (corresponding to objects of the prior art 1). Pages P4, P5, P6, and P7 located in the lower part of FIG. 7 and 701 are called leaf pages, and each has one or more keys (values shown in the lower part of the page. For example, in page P6, key value 50 and key value 70) and a set of storage position information of the corresponding data, a pointer on the right page (excluding the rightmost page P7), a MAX key value in the page (value shown at the upper right in the leaf page, stored in the page) The maximum key value of the stored data (for example, the key value 20 in the page P4 is the in-page Max key value) is stored. Each leaf page has a range of keys in charge of storage, and is indicated by the in-page Max key value of the corresponding page and the page located on the left side thereof. For example, the range of keys that the page P5 is responsible for storing is a key that is greater than the in-page Max key value 20 of the page P4 on the left side of the page P5 and less than or equal to the in-page Max key value 40 of the page P5. Similarly, the ranges of keys assigned to pages P6 and P7 are keys greater than 40 and less than 70, and keys greater than 70, respectively. The page P4 having no page located on the left side is in charge of a key equal to or less than the Max key value in the page (20 or less).
[0016]
Above the leaf page, a page called an upper page (page P1, page P2 and page P3 in FIG. 7, 701, also called a node) is arranged. The upper page stores a pair of pointers and key values to one or more immediately below pages, and a pointer to the right page (if any). The key value here matches the in-page Max key value of the page pointed to by the paired pointer. In particular, the page P1 is called a root page. In order to search for a leaf page in which a certain key value is stored, it is only necessary to access from the root page and trace a pointer paired with a minimum key value equal to or greater than the target key value. The area is secured on a page basis.
[0017]
Here, a deletion process in which a key value in the range of key values 20 to 40 is designated will be described with reference to FIG. First, the IX mode lock is set for the entire B-tree index T, the lock is set for the root page P1 in the S mode, and the key value is 20 or more, which is the lower limit of the specified range, in the page P1. A pointer to the page P2 paired with the key value 40 that is the minimum key value is acquired, and the lock of the page P1 is released. A lock is set for the page P2 in the S mode, and similarly, a pointer to the page P4 that is paired with the key value 20 that is the key value 20 or more and is the minimum key value in the page P2, The lock of page P2 is released. Then, the lock is set for the page P4 in the X mode, and all the key values in the range of the key values 20 to 40 to be deleted in the page P4 are deleted.
[0018]
At this time, since only the key value 20 exists in the page P4, no key value remains in the page, but the area of the page P4 is not released. The main reason is that in order to release the area, it is necessary to reset the pointer to the page to be released while setting an appropriate lock, which leads to deterioration of parallel execution.
[0019]
Further, since the Max key value in the page of page P4 is 20, it can be seen that a key value larger than 20 is stored in the right page in the range of key values 20 to 40 to be deleted. A pointer to the page (pointer to page P5) is acquired, and the lock of page P4 is released. An X mode lock is set for page P5, and all key values in the range of key values 20 to 40 to be deleted in page P5 are deleted. At this time, since only the key value 40 exists in the page P5, no key value remains in the page, but the area of the page P5 is not released. Since the Max key value in the page of page P5 is 40, all the keys in the range of key values 20 to 40 can be deleted. The page P5 is unlocked, and finally the entire B-tree index T is unlocked to complete the deletion process. A state where the deletion process is completed is shown in FIGS.
[0020]
A procedure for performing the insertion process (key value 60) from the state of FIGS. 7 and 702 will be described with reference to FIGS. Set the IX mode lock for the entire B-tree index T, access the pages P1 and P3 and the page in the same way as described above, and set the X mode lock for the page P6. Access page P6. It is assumed that the data of the key values 50 and 70 are already stored in the page P6 and there is not enough space for storing the data of the key value 60. In this case, page division processing called split is performed. First, a new page is secured (referred to as page P8). Here, it is assumed that the division key value is 50. In other words, the data of the key value 50 is left on the page P6, and the data of the key value 70 and the data of the key value 60 to be inserted are moved to a newly reserved page area. Make necessary settings for page P8, reset the Max key value in page P6 to 50, reset the right page pointer to page P8, etc., and then unlock page P6. The page P3 is locked in the X mode, the pointer is reset, the page P3 is unlocked, and finally the entire B-tree index T is unlocked to complete the insertion process. A state where the insertion processing is completed is shown in FIGS.
[0021]
As described above, in the B-tree index, in order to maintain high parallel executability, even if there is no data in the page due to data deletion, the page area is not released. For this reason, the storage efficiency generally decreases as data insertion / deletion is repeated, and the access performance deteriorates accordingly. In order to suppress the performance degradation, generally, a process (reorganization process) is performed in which index access is prohibited at an appropriate time, the data stored in the index is output to a temporary area, and the data is repacked. .
[0022]
As described above, the conventional technique 2 does not lock two pages at the same time. Therefore, the possibility of parallel execution is high. On the other hand, there is a possibility that an erroneous page reference as described in the prior art 1 may occur. Therefore, even if data is deleted, the area cannot be subsequently released.
[0023]
[Problems to be solved by the invention]
As can be seen from the description of the prior art 1 and the prior art 2 as described above, there is a trade-off between the ability to release the area in the data deletion process and the high parallel execution performance. It was thought.
[0024]
An object of the present invention is to have a data structure in which a plurality of objects are associated with each other by a pointer, and in a system in which a plurality of processes for referencing, updating, inserting and deleting objects operate in parallel, the parallel execution of reference, update and insertion And deletion processing can be executed in parallel with reference, update, and insertion processing.
[0025]
Furthermore, storage efficiency and access efficiency decrease due to repeated insertion and deletion of data (the number of objects that have been deleted but the area is not released increases, or the object passes through an object that is unnecessary to access the target object. In other words, a free object area is recovered without inhibiting data reference, update, and insertion, and storage efficiency and access efficiency are improved.
[0026]
[Means for Solving the Problems]
In reference, update, and insert processing, when moving between objects by following the pointer, the lock on the object before the movement is released, and then the reference, update, and insertion are executed in parallel by releasing the lock on the object after the movement. Increase sex. At this time, the IS mode (in the case of reference processing) or the IX mode (in the case of update and insertion processing) is set for the object group at the beginning of the processing, and the lock is released when the processing is completed.
On the other hand, in the deletion process, after the pointer to the deletion target is separated or replaced, the area of the deletion target object is released after all the processes for acquiring the lock on the object group are completed.
[0027]
DETAILED DESCRIPTION OF THE INVENTION
(Embodiment 1)
An example of a system configuration for realizing the present invention is shown in FIG. The system configuration example shown here is common to the first to third embodiments. This system includes a computer system 1 having a processor 2 and a memory 3, an external storage device 4 connected thereto, and a plurality of terminals 7 connected to the computer system 1 via a network 6.
[0028]
A data management system 10 expressed in the form of a program that can be interpreted by the processor 2 is arranged in the memory 3, and instructions are read and processed by the processor 2. The data management system 10 includes a system control unit 11, an object management unit 12, and a lock management unit 13. The system control unit 11 receives a reference, insertion, update, and deletion request from the terminal 7, analyzes the request content, passes control to the object management unit 12, and returns a processing result to the terminal 7 through the network 6. The object management unit 12 manages the object 5 stored in the external storage device 4 in accordance with the instruction given from the system control unit 11. The lock manager 12 provides the object manager 12 with a lock function for the specified resource.
[0029]
In FIG. 1 used for the description in the prior art 1, an example of a method in which parallel execution of reference, update, and insertion is higher, and deletion processing can be referred to, updated, and inserted can be executed in parallel with FIG. 3 and FIG. 4. Disclose.
[0030]
3 and 301 are time charts showing reference processing in the present embodiment. Compared to FIGS. 2 and 201, the unlocking timing of the object A and the S mode locking timing of the object B are switched. That is, conventionally, the lock is set for the object A, the value of the pointer to the object B is stored, the lock is set for the object B, and then the lock for the object A is released. On the other hand, in this embodiment, if the lock is set for the object A and the value of the pointer to the object B is stored, the lock for the object A is released. Then, lock is set for the object B. 3 and 302 are time charts showing the insertion processing in the present embodiment. This is the same as FIG.
[0031]
3 and 304 are time charts showing the update processing in the present invention. Compared to FIGS. 2 and 204, the unlocking timing of the object A and the X mode locking timing of the object B are switched.
[0032]
3 and 303 are time charts showing the deletion processing in the present invention. 2 and 204 are significantly different, and will be described with comparison. The setting of the IX mode lock for the object group T and the setting of the X mode lock for the object A are the same, but thereafter, all processes that have acquired the lock for the object group T are stored. Thereafter, the pointer to the object C to be deleted is separated from the object A, but in this embodiment, the completion of all the stored processes is awaited here. As a method of waiting for completion, a method of notifying the deletion processing of completion from the processing side that has set the lock on the object group T at the time of releasing the lock, and checking the completion of processing of other processing at regular intervals There is a way to do it. After the completion of all the stored processes can be detected using any method, the area of the object C is released.
[0033]
Since there is no possibility that another process accesses the released area, there is no need to set a lock on the object C. The reason will be described with reference to FIG. FIG. 4 shows that the deletion process 401, the reference process 402, the insertion process 403, the update process 404, and the update process 405 are performed in parallel. At 406, that is, immediately after setting the lock on the object A in the X mode in the deletion process 401, the process that does not set the lock on the object group T (in this case, the update process 404 and the update process 405) Inaccessible. This is because it is necessary to access the object A at the time when the pointer to the object C is set before accessing the object C, but the deletion process 401 is held in the X mode, so the update process 404 and the update process 405 are performed. When the object A can be seen, the pointer to the object C is cut off. The reference process 402 and the update process 403 may acquire data by looking at the object C because it is possible to detect that these processes have been completed.
[0034]
The IS mode and the IX mode are examples, and a lock mode equivalent to the set or a lower parallel execution capability can be used instead.
[0035]
By the above processing method, the parallel execution performance of the reference, insertion and update processing is enhanced as compared with the conventional processing, and other processes are prevented from erroneously accessing the area released by the deletion processing. More specifically, in the above embodiment, in the reference, insertion, and update processes, one process does not lock two objects at the same time, so that high parallel execution performance equivalent to that of the prior art can be realized. In the deletion process, after detaching the pointer, the area of the deleted object is released after waiting for the completion of other processes that lock the object group that is the target of the deletion process. The area can be released without obstructing the execution of other processes.
[0036]
(Embodiment 2)
A second embodiment will be disclosed with reference to FIGS. 5 and 6.
5 and 501 are data structures typically used in the case where data corresponding to a certain hash value is managed by a chain (here, the hash function is defined as a remainder obtained by dividing the key value by 10; It is assumed that this is the part that manages the key and data with hash value = 2). A procedure when a deletion process of the key value 32 and an insertion process of the key value 12 are requested for the data structure in this state will be described with reference to a time chart of each process shown in FIG.
[0037]
In the deletion process 601 in FIG. 6, a deletion request is made for the object B. First, the IX mode lock is set for the object group T, and the lock is set for the object A in the X mode. A pointer to the object B stored in the object A is acquired, an X mode lock is set for the object B (while holding the lock for the object A), and the object B is accessed. Confirm that there is an object B, that is, an object with a key value of 32, and store all the processes that have set the lock for the object group T at this time (the insertion process 602 is also executed in parallel at this time). It is assumed that a lock is set for the object group T). The pointer to the object B stored in the object A is reset to the pointer stored in the object B (pointer to the object C) (pointer replacement), and the locks of the objects A and B are released (see FIG. 5, 502), waiting for completion of the stored processing.
[0038]
On the other hand, in the insertion process 602, the lock of the IX mode is set for the object group T, the object area for insertion is secured (object D), and the key value 12 and related data are set. Subsequently, a lock is set for the object A in the X mode (if the deletion process is in the lock state, it will wait until the release), the pointer stored in the object A is set as a pointer to the object D, The pointer from the object A is changed to point to the object D, the lock of the object A is released, and finally the lock of the object group T is released, and the insertion process is completed (503 in FIG. 5).
[0039]
By releasing the lock of the object group T in the insert process 602, the delete process 601 releases the area of the object B (without setting the lock), releases the lock of the object group T, and completes the delete process (see FIG. 5, 504).
[0040]
Next, the processing procedure of the reference process (key value 62) 603 will be described. First, the IS mode lock is set for the object group T, and the object whose key value is 62 is searched by following the pointer sequentially from the object A. When moving between objects, the lock of the movement source object is released, and then the movement destination object is locked in the S mode. When operating in parallel with the deletion process 601, if the state when the object A is accessed is the state shown in FIGS. 5 and 502, the object B is not accessed and the pointer points to the object C. Is remembered. Therefore, the process surrounded by the dotted line in FIG. The process surrounded by the dotted line 603 is executed when the object B is still in the state 501. At this time, the pointer to the object B is stored by accessing the object A, and the pointer to the object C is stored by the process surrounded by the dotted line. In this way, the processing changes depending on the reference timing.
[0041]
Next, the processing procedure of the update process (key value 62) 604 will be described. First, the lock of the IX mode is set for the object group T, the object whose key value is 62 is searched in order from the object A, and when it is found, the associated data is updated. When moving between objects, the lock of the movement source object is released, and then the lock of the movement destination object is set in the X mode. When operating in parallel with the deletion process 601 described above, if the state when the object A is accessed is the state shown in FIGS. 5 and 502, the object B is not accessed, and the dotted line in FIGS. The process surrounded by is not performed.
[0042]
According to the processing method, high parallel execution of reference, insertion, and update processing can be realized without erroneously accessing the area released by the deletion processing. Furthermore, in the data management using the hash function, as in the first embodiment, in the reference, insertion, and update processes, one process does not set locks on two objects at the same time and is highly parallel. In the deletion process, after detaching the pointer to the object to be deleted, waiting for the completion of the other process that locks the object group and releasing the area, the other process is executed. The area can be released without impeding execution and without using wrong data.
[0043]
(Embodiment 3)
A free page collection processing method that can be executed in parallel with data deletion and data insertion processing in the B-tree index described in the prior art 2 will be disclosed with reference to FIGS. It is assumed that the free page collection process is executed instead of reorganization at an appropriate time when the storage efficiency is lowered while the data insertion / deletion is repeated and the access performance is deteriorated accordingly.
[0044]
FIG. 8 and 803 show the processing procedure when the empty page collection processing is executed in the state of FIGS. First, a lock is set in the IX mode for the entire B-tree index T. In the following description, the mode for locking the page is described in []. Next, the page is traced from the root page toward the leftmost leaf page (pages P1 [S], P2 [S] and P4 [X]). After confirming that the number of data items is 0 on the leaf page P4, a flag indicating that the data is scheduled to be collected (FIG. 7, 704, a symbol with “times” in a round frame in the page P4) is set. Subsequently, the page P2, which is the upper page of the page P4, is accessed [X], and the pointer to the page P4 is separated (704 in FIG. 7). Then, the page P5 which is the page on the right side of the page P4 is accessed [X], it is confirmed that the number of data is 0, and a flag indicating that the data is scheduled to be collected is set. Next, it accesses [X] the page P2, which is the upper page, and confirms that no key remains in the page P2 when the pointer to the page P5 is cut off. Set the flag. Subsequently, the page P1, which is the upper page of the page P2, is accessed [X], and the pointer to the page P2 is disconnected (705 in FIG. 7). The page P6 which is the page on the right side of the page P5 is accessed [X] to confirm that the number of data is one or more, and the page P8 which is the page on the right side of the page P6 is accessed [X] and the number of data is 1 Confirm that the number is more than the number, access page X7 on the right side of page P8 and check that the number of data is one or more, set flag of recoverable page and detach the pointer Is completed. At this time, the process that sets the lock for the entire B-tree index T is stored, and the completion of those processes is awaited. When all the stored processes are completed, the areas of the pages P2, P4, and P5 that are scheduled to be collected are released, and finally the entire B-tree index T is unlocked to complete the free page collection process (FIGS. 7 and 706). .
[0045]
In the final form obtained by the above-described empty collection processing method, the right page takes over the key for which the area released page is responsible for storage. For example, page P6 is responsible for data with a key value of 50 or less. Accordingly, in the reference, insertion, and update processing, when it is detected that the collection schedule flag is set for the accessed page, the processing is partially changed so that the page is moved to the right side and accessed.
[0046]
By the processing method described so far, even in the B-tree index, the page area that is free without significantly impairing the parallel execution of reference, insertion, and update processing and without inhibiting data reference, update, and insertion It is possible to improve storage efficiency and access efficiency.
[0047]
As described in the above-described embodiment, in a system having a data structure in which a plurality of objects are associated by pointers and a plurality of processes for referencing, updating, inserting and deleting objects operate in parallel, referencing and updating In addition, it is possible to perform parallel processing of insertion and parallel execution with reference to the update processing, insertion processing, and insertion processing.
[0048]
In addition, for B-tree indexes whose storage and access efficiencies have decreased due to repeated insertion and deletion of data, pages that are empty without inhibiting data reference, updating, and insertion, or using temporary resources It is possible to improve the storage efficiency and the access efficiency.
[0049]
【The invention's effect】
According to the present invention, parallel execution of reference, insertion, and update processing is possible, and it is possible to release (recover) after deletion processing by avoiding other processing from accidentally accessing an area released by deletion processing. It is said.
[Brief description of the drawings]
FIG. 1 is a diagram showing a data structure in Conventional Technology 1 and Embodiment 1. FIG.
FIG. 2 is a diagram showing a time chart in prior art 1;
FIG. 3 is a diagram showing a time chart in the first embodiment of the present invention.
FIG. 4 is a diagram showing a state of parallel processing in Embodiment 1 of the present invention.
FIG. 5 is a diagram showing a data structure in Embodiment 2 of the present invention.
FIG. 6 is a diagram showing a time chart in the second embodiment of the present invention.
FIG. 7 is a diagram showing a data structure in the prior art 2 and the third embodiment of the present invention.
FIG. 8 is a time chart in the related art 2 and Embodiment 3 of the present invention.
FIG. 9 is a diagram showing an example of a system configuration for realizing the present invention.
[Explanation of symbols]
DESCRIPTION OF SYMBOLS 1 ... Computer system, 2 ... Processor, 3 ... Memory, 4 ... External storage device, 5 ... Object, 6 ... Network, 7 ... Terminal, 10 ... Data management system, 11 ... System control part, 12 ... Object management part, 13 ... lock management department

Claims (3)

In a data processing method for performing arithmetic processing on a data management system held as a program in a memory of a computer system and executed by a processor,
The data management system includes:
An object manager,
A lock management unit,
It is possible to access the next object from one object by pointing to one object and the next object, an object group consisting of multiple objects, an object that is a data unit in which the area is secured and released as one thing Has a data structure consisting of a pointer that allows
When performing object reference, update, insertion, and deletion processing, a lock is set for the object group, and thereafter, a specific object in the object group is moved to the object to be processed by the pointer. A data processing method for setting an object lock on an associated object and causing the data management system to operate a plurality of object reference, update, insertion, and deletion processes in parallel.
A first step of setting a first lock on the object group when the program of the lock management unit is executed by the arithmetic processing by the processor and performing a deletion process;
For the object associated with the pointer from the specific object in the object group to the object to be deleted to be deleted, the program of the lock management unit is executed by being processed by the processor . A second step of setting a second lock;
All processes other than the deletion process that are executed when the program of the object management unit is arithmetically processed by the processor to acquire the lock on the object of the object group to which the deletion target object that performs the deletion process belongs. A third step of storing information;
A fourth step in which the program of the object management unit is executed by an arithmetic processing performed by the processor and prevents the deletion target object from being pointed to from the object that points to the deletion target object to be deleted;
The object management unit program is executed as a result of arithmetic processing by the processor, and it is determined that all processes other than the deletion process for acquiring a lock on the object group have been completed. Steps,
And a sixth step of releasing the area of the object to be deleted when the program of the object management unit is executed by arithmetic processing by the processor and it is determined that all the processes are completed. A data processing method. The data processing method according to claim 1, wherein in the fifth step, the program of the object management unit receives a process completion notification from a process other than the deletion process that has acquired a lock on the object group. . When the program of the object management unit is executed by the arithmetic processing by the processor , and a reference, update, insertion and deletion process is executed for a certain object, a specific point serving as a base point of the object group 2. The data processing method according to claim 1, wherein the object to be processed is searched by sequentially tracing the pointer from the object.

Images