Method and System for Using Bitmask Indications and Buffers to Cache Server Data (19-Aug-2009)
Our invention is to implement a solution for using bitmask indications and buffers to cache server data for the client applications. In this architecture, one new module named Indication Buffer is involved into existing indication model and the main function of this module is to buffer bitmask indications, merge indications, and finally invoke the query method to communicate with the server to update cache at a time. Traditionally, when the indication listener on client side receives one indication from the indication dispatcher, it will communicate with the server to query related object information to update cache subsequently, because in most case, the indication only notifies which objects have been changed in server, while it doesn’t include any information about how these objects changed. If lots of such indications arrive in a short time, the client application will consume a large deal of computer and network resource to fetch data and update cache. Here, we propose one feasible solution to the above problem, using bitmask indications and buffers to cache server data, it reduces the times for accessing server, and the cache data can be updated in time. The whole process of our invention is described as follows: 1. Plug the Indication Buffer module into existing indication framework, and launch it to buffer bitmask indications. 2. Get the bitmask indications from the listener, which are received from the dispatcher, put them in the buffer, and merge them together if it’s possible. The outputs can be bitmask strings and be put back in the buffer. 3. Use the output bitmask as direction to contact with the server to fetch correlated information at a time, and update the cache to keep consistency at last.
Method and System for Using Bitmask Indications and Buffers to Cache Server Data
Client-server network configurations are well known in the
computer arts, which have been widely used in system
management software. One client requests information and such
information are provided, or served-up, by its server. In
order to speed up the access performance to information on
server, the client application usually maintains a cache to
store such data locally. Technically speaking, this cache
should be updated in real time, otherwise the information will
be out of date, and cause the client application to be
inconsistent with the server
In most case, the client application may subscribe for certain
indications on certain objects in the server. When the state
of any of those certain objects change, an indication is fired
back to the client side to indication a state change, and this
indication can be used to update the client-side cache
subsequently.
One of the major challenges a client management application
faces is to use the indications effectively to keep the
client-side cache has the latest updates. Generally speaking,
one indication wrapping the changed object is sent to the
indication listener from the indication dispatcher, which is
used to keep coherency with the data on server side. However,
the latency between changing the object in the server and
receiving the related indication in the client exists more or
less in practice, and so if we only depend on such indication,
the data inconsistency will become obvious because the object
status might be changed again when the indication arrives at
the client application. In addition, indications only notify
which objects have been changed in some cases, while they don'
t show how these objects changed.
Querying the object information which the indications notify
immediately from the server again will solve the problems
mentioned above. However, if we get lots of frequent and
trivial indications, it will be time-consuming to update all
of them in the client-side cache, and also add load to the
server-side application, because it will consume a large deal
of computer and network resource to fetch information.
Fortunately, we can use bitmask indications to trace which
objects have been changed in the server, and employ buffers to
keep these indications within a specific period in the client,
and at last, most of the indications can be merged together,
so fewer query operations are needed then to update the cache.
Our invention is to implement a solution for using bitmask
indications and buffers to cache server data for the client
applications. In this architecture, one new module named
Indication Buffer is involved into existing indication model
1
and the main function of this module is to buffer bitmask
indications, merge indications, and finally invoke the query
method to communicate with the ser...
Find More Documents Like This
Download this Disclosure
Click here if you want to sign-in now.
