Browse Prior Art Database

Access Authorization for Cache Coherence Control

IP.com Disclosure Number: IPCOM000120355D
Original Publication Date: 1991-Apr-01
Included in the Prior Art Database: 2005-Apr-02
Document File: 2 page(s) / 87K

Publishing Venue

IBM

Related People

Liu, L: AUTHOR

Abstract

A technique is described whereby an access authorization mechanism performs a cache invalidate automatically for software-oriented cache coherence control.

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

Access Authorization for Cache Coherence Control

      A technique is described whereby an access authorization
mechanism performs a cache invalidate automatically for
software-oriented cache coherence control.

      In prior art, object-oriented cache coherence control
mechanisms were based on software locking.  The basic idea was that
in a multi- processor (e.g., highly coupled) system certain portions
of the data may be shared (e.g., at byte level) by different
processors.  The shared data was partitioned into a set of objects.
The memory was considered partitioned into blocks.  The block size
was a multiple of the cache line size.  For instance, a block may
simply be a 4K page.  The shared data was allocated by the system
such that a block could not contain data from two different objects
at the same moment.  Software control of the cache coherence was on
an object basis.  It was assumed that there were certain
synchronization primitives (e.g., semaphores) and that either
non-cacheable or that they were maintained consistent through special
cache coherence mechanisms.  Accesses from a central processor (CP)
to a shared object should obtain proper synchronization (e.g., EX or
RO locks) via the synchronization primitives.  After the usage of a
shared object, a CP released its lock.  Upon lock release (or CP
switch) the CP invalidated the lines belonging to the object in its
cache.  The caches could be store-thru for shared object modifies.

      In the prior art software coherence control (for shared
objects), one potentially costly operation was the search for lines
to invalidate upon lock releases.  More standard implementation would
involve a directory search to match proper tags.  In the concerned
environment, the portions of lines accessed for shared data in a
cache are relatively small and are not expected to stay in cache for
long periods of time.  As a result, the cache control may maintain a
separate authorization directory to control the access to shared
data.  With appropriate designs, upon a lock release, the cache
control only needs to check the smaller authorization directory
without affecting the operation of the cache.

   ...