Browse Prior Art Database

Asynchronous Data Invalidation in Data Sharing Systems

IP.com Disclosure Number: IPCOM000122650D
Original Publication Date: 1991-Dec-01
Included in the Prior Art Database: 2005-Apr-04
Document File: 4 page(s) / 179K

Publishing Venue

IBM

Related People

Liu, L: AUTHOR

Abstract

Disclosed are techniques for asynchronous processing of XI-invalidations in a multisystem data sharing environment. Special means is provided for the guarantee or verification of completion of issued XI-invalidates prior to the record lock release phase of a transaction. The benefit is improved performance for data sharing systems.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 36% of the total text.

Asynchronous Data Invalidation in Data Sharing Systems

      Disclosed are techniques for asynchronous processing of
XI-invalidations in a multisystem data sharing environment. Special
means is provided for the guarantee or verification of completion of
issued XI-invalidates prior to the record lock release phase of a
transaction.  The benefit is improved performance for data sharing
systems.

      In a multisystem data sharing environment, a critical issue is
to maintain data coherence cross systems.  There have been various
approaches to this problem.  We are currently concerned with a data
sharing system design in which special hardware support is provided
for cross-systems data invalidation, as described in (*).  Consider
such a data sharing system with N system nodes {Si}, each having a
special
lookaside table Ti recording information on validity of shared data
pages for Si .  In the illustration, a central controller C is
assumed
that handles cross-systems activities.  In addition to typical record
level locking, certain page level locking is assumed to prevent each
particular page from being modified at multiple nodes.  In the
following we assume that the central control C is responsible for the
management of page locking for multiple systems.  Different systems
may hold write locks on different records of the same data page.
However, each time a system writes into a page, the (exclusive) page
lock should be held.  Furthermore, whenever a system holds the page
lock, the data page should be up-to-date (i.e., with most recent
changes) at the local buffer pool (if existing there).  If a system
holds a page lock while the data page is missing in its local buffer
pool, the shared store should contain the up-to-date copy. Record
locks held by a transaction are released during commit time as usual.
A page lock held by a system may, however, be stolen by other systems
at any moment.  For instance, when Si needs to
write into a page P while another system Sj is holding the associated
page lock, Si will request the page lock to C first and C will
trigger
the stealing of the page lock from Sj .  When a page lock is being
stolen from a system, all the changes to the page should be updated
at the shared store first.  Prior to the commit (in particular the
release of record locks) of a transaction T at a system, all shared
pages changed by T should be updated at the shared store first (if
not yet done).  Whenever a page with new changes is updated from a
system to the shared store, C will signal XI-invalidates to all other
systems that may possibly hold the page in their local buffer pools.
This invention will focus on the processing of XI-invalidates and
ignore other important operations (e.g., locking) in data sharing.
Basic Idea of the Invention

      In a more straightforward implementation, the XI-invalidates
are handled in synchronous manner.  For instance, consider the
situation when C issues to Sj the XI-invalid...