Browse Prior Art Database

Scheme to Bypass Cache for Big, One-Time Writes

IP.com Disclosure Number: IPCOM000106475D
Original Publication Date: 1993-Nov-01
Included in the Prior Art Database: 2005-Mar-21
Document File: 2 page(s) / 83K

Publishing Venue

IBM

Related People

Knox, T: AUTHOR [+3]

Abstract

During IBM OS/2* LAN Server 2.0 (Advanced Server) development, it was found that big data writes to the server were very slow when the cache was full. Also, caching one time writes was a costly waste of the cache.

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

Scheme to Bypass Cache for Big, One-Time Writes

      During IBM OS/2* LAN Server 2.0 (Advanced Server) development,
it was found that big data writes to the server were very slow when
the cache was full.  Also, caching one time writes was a costly waste
of the cache.

      The IBM LAN Server 2.0 Advanced Server package includes a
module (HPFS386) that is both a filesystem and file server.  The
filesystem keeps an in-memory cache of the file data on disk.  Of
course, the cache can only keep a small portion of the disk data,
therefore only the most recently read or written data is kept in
cache.

      The filesystem provides an interface to the server that allows
the server to receive data directly from the network into cache.
Without receiving directly into cache, data must be copied from a
server buffer to cache.  For big write requests, for example 64Kb,
the server uses the cache transfer mechanism, thus saving the costly
time it takes to copy the data.

      A performance analysis showed that there are times when the
cache transfer mechanism for big write requests is extremely slow.
These are times when the data being written is not already in cache,
and cache space had to be made available for the new data, since that
meant existing cache data had to be written to disk before the write
could commence.

      Therefore, it was realized that performance could be improved
if the cache could be bypassed completely in these big write cases.
Instead of receiving into cache, the data could be received into a
server buffer and written directly to disk from the buffer.  But, the
idea of not writing a file into cache defeats the purpose of the
cache if there will be requests for that file in the near future.  It
was also realized that big write requests should bypass the cache
only on big files that are most likely being written just this one
time.  Performance analysis showed that it was only files greater
than around 120 Kbytes that should bypass the cache.  Consequently,
the scheme had to include some way of determining when a file was (or
was to become) greater than 120 Kbytes during the write operation.
The following section describes the scheme used to bypass the cache
for big write requests.

      The server receives requests from client...