Browse Prior Art Database

Update Merging Mechanism for Shared Memory in Multi-Systems

IP.com Disclosure Number: IPCOM000062205D
Original Publication Date: 1986-Oct-01
Included in the Prior Art Database: 2005-Mar-09
Document File: 3 page(s) / 51K

Publishing Venue

IBM

Related People

Dias, DM: AUTHOR [+3]

Abstract

Experiments have shown that block locks account for a large proportion of lock contention in a multi-system data sharing environment. Since lock contention increases as the number of concurrent transactions increases, the growth in contention can limit the transaction throughput that can be sustained by the system, and consequently, the horizontal growth of a transaction processing complex. By eliminating the need for block locks, the present mechanism can allow a larger throughput to be supported in the multi-system environment. The necessity for block locks on update in current multi-systems (that do not have a shared buffer between processors and a shared disk) is for the following reason. The unit of transfer from disk to processor local buffer is a block.

This text was extracted from a PDF file.
At least one non-text object (such as an image or picture) has been suppressed.
This is the abbreviated version, containing approximately 52% of the total text.

Page 1 of 3

Update Merging Mechanism for Shared Memory in Multi-Systems

Experiments have shown that block locks account for a large proportion of lock contention in a multi-system data sharing environment. Since lock contention increases as the number of concurrent transactions increases, the growth in contention can limit the transaction throughput that can be sustained by the system, and consequently, the horizontal growth of a transaction processing complex. By eliminating the need for block locks, the present mechanism can allow a larger throughput to be supported in the multi-system environment. The necessity for block locks on update in current multi-systems (that do not have a shared buffer between processors and a shared disk) is for the following reason. The unit of transfer from disk to processor local buffer is a block. If two systems need to update different records within the same block, they obtain record locks on the blocks. In addition, they must request global block locks for this block. If no block lock was obtained, both systems may concurrently update different records on the same block, and write the block out to disk. Since the disk writes are sequential, one of the record updates on the block would be lost. If, on the other hand, a block lock is obtained the first system that updates the block sends a block invalidate message to other systems after reflecting the update to the disk, indicating that the block has been changed. Another system that updates the block must now get it from disk before updating it, thus maintaining consistency. Merely interposing a shared buffer between the systems and the shared disk, as shown in Fig. 1, does not directly allow elimination of block locks. The reason is that a block is the unit of transfer out of the local system buffer to the disk, and to change this would require considerable changes to the local buffer manager and access methods. A goal of the scheme proposed here is to minimize changes to the local system software and access methods. Thus, the unit of transfer between the local buffer and the shared buffer is still a block, and the merging of updated records is done transparently, as described below. It is assumed that concurrency control in the basic system structure, as shown in Fig.1, is done using record locking. Thus, no two systems will simultaneously update the same record. However, as discussed above, two systems may simultaneously update different records in the same block. Now, if the entire block is copied from local buffer to shared buffer, for each record update one of the simultaneous updates will be lost. Clearly, this lost-update problem can be eliminated if for each update, only the updated record is changed. We observe that the updated record can be identified by comparing the version of the block that was read into a local buffer, with the version that is written out. This is illustrated in Fig. 2. Here, both systems X and Y read in...