Electrical computers and digital processing systems: multicomput – Multicomputer data transferring via shared memory
Reexamination Certificate
1998-12-01
2001-05-15
Coulter, Kenneth R. (Department: 2154)
Electrical computers and digital processing systems: multicomput
Multicomputer data transferring via shared memory
Reexamination Certificate
active
06233606
ABSTRACT:
FIELD OF THE INVENTION
The invention relates generally to computer systems, and more particularly to the caching of content such as downloaded network content.
BACKGROUND OF THE INVENTION
For network client applications, such as web browsers, a limiting performance factor is often low bandwidth to the server. To mitigate this low-bandwidth problem, network client applications often cache content replicated from servers, so that as much information as possible is kept available on the client user's hard drive. As data access times from the hard drive and RAM are typically orders of magnitude faster than download times, some or all of a server's content may often be rapidly accessed from the cache with little or no downloading of data from the server. Other types of caching are directed to similar problems.
In general, to cache content, the local machine stores the data in a database, file system or system memory. To retrieve content, the cache is queried for items with acceptable attributes and one is chosen according to the application's criteria. For example, more than one translation of a text document might be acceptable to a user.
If there is a strict mapping of at at most one acceptable cached item per query, the content can be indexed by a unique lookup key, such as a Uniform Resource Identifier (URI), a compact string of characters for identifying an abstract or physical resource. Examples of URIs include URLs (Uniform Resource Locators), URNs (Uniform Resource Names), and other standard namespaces. A URI may be used as the lookup key to a cache, as can other names, such as a globally unique identifier (GUID).
While content caching thus provides substantial performance improvements, a problem with caching is that the locally cached content is static, whereas the content (e.g., network content) may or may not have changed. To avoid this problem, HTTP (hypertext transfer protocol) provides for sending a conditional request, e.g., an “If-Modified-Since” (IMS) request, an “If-None-Match” request, or the like to the server, identifying the content by a timestamp or entity tag. When the server receives such a conditional request, it uses the timestamp and/or entity tag to test whether the content has changed, and, if the content has not changed, the server responds with a “not modified” response, otherwise the server provides the modified content.
While this provides an overall increase in the available network bandwidth by reducing the amount of data that needs to be transmitted, not much in the way of savings is achieved at the server end. More particularly, the server often does almost as much work to determine if a content has been modified as it takes the server to simply retrieve and return the corresponding requested content. At the same time, many conditional requests may be made for content that is rarely, if ever, modified. This wastes server resources, increases client latency and also consumes available bandwidth.
One solution is to have the provider of the content indicate an “Expires” header comprising a date/time stamp, “Cache-Control” header specifying a max-age relative to the current time, or the like. When cached, the local system ordinarily does not send a conditional request before the particular time determined by the expiry mechanisms. However, this only works when the content provider provides an appropriate timestamp header, which frequently does not happen, sometimes because it is not appropriate for the content to have a distant expires time, e.g., it is expected to change frequently, and sometimes because it is simply not used by the provider.
Another solution is to have the local system only occasionally check to determine if cached content has been modified, based upon some criteria such as user action or a time schedule. For example, when particular content that is in the cache is requested, a browser may send an If-Modified-Since request for that content only once per browser session and/or once per day, and so on, (although the user can force a refresh as desired). This solution may work in conjunction with expiry mechanisms, for example, always check if the content is known to be expired, otherwise check according to the schedule.
However, both solutions still result in a large number of conditional requests being sent for content which rarely, if ever, changes. Explicit expiry information from the server often fails for static content since many providers do not use it, while the scheduled refreshing solution reduces conditional requests to an extent but still results in many requests for content that has not been modified. For example, a typical user may only browse much of the cached content once per session and/or once per day, whereby this second solution hardly, if at all, results in a reduced number of conditional requests taking place.
SUMMARY OF THE INVENTION
Briefly, the present invention provides a method and system for reducing the number of requests for cached content, such as conditional requests for network content to a server, by maintaining state for selected URIs or the like in a local cache indicative of a confidence level that the content is unchanged. Selected URIs may be from among content types which are less likely to change. URIs must achieve a certain confidence level by passing one or more confidence tests before they are placed in an automatic synchronization mode, otherwise those URIs are considered volatile.
When a request for content is received that corresponds to a cached data that is in the automatic synchronization mode, a synchronization time is determined based on a confidence level for that URI. If the synchronization time is achieved, (i.e., by the current time), a conditional request is sent, otherwise data is returned from the cache to respond to the request. Synchronization intervals for such URIs may be increased as the likelihood that the item is unmodified increases.
REFERENCES:
patent: 3985998 (1976-10-01), Crafton
patent: 5390318 (1995-02-01), Ramakrishnan et al.
patent: 5442760 (1995-08-01), Rustad et al.
patent: 5628015 (1997-05-01), Singh
patent: 5737599 (1998-04-01), Rowe et al.
patent: 5787470 (1998-07-01), DeSimone et al.
patent: 5787475 (1998-07-01), Pawlowski
patent: 5863207 (1999-01-01), Powell
patent: 5864852 (1999-01-01), Luotonen
patent: 5889958 (1999-03-01), Willens
patent: 5991760 (1999-11-01), Gauvin et al.
patent: 6061715 (2000-05-01), Hawes
patent: 6067565 (2000-05-01), Horvitz
patent: 6085226 (2000-07-01), Horvitz
patent: 6112231 (2000-08-01), DeSimone et al.
Coulter Kenneth R.
Michalik & Wylie PLLC
Microsoft Corporation
LandOfFree
Automatic cache synchronization does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Automatic cache synchronization, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Automatic cache synchronization will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2559089