Next: An Example
Server Up: High-Performance
Caching With The Previous: Rationale
Figure 1: Server Architecture. A customized
server has modules of two different types: hit-server(s) and
miss-server(s). They are dedicated machines and are connected
with a dedicated intra-server network. Client libraries reside on
each client and are responsible for communicating with the
hit-server via a LAN.
The server architecture consists of two types of modules that cooperate to manage a large RAM cache of objects (shown in Figure 1). A hit-server is a highly-optimized generic module (a dedicated machine) that handles client requests that hit in the object cache. Miss-servers handle client requests that miss in the object cache. Miss-servers also implement application-specific policies for managing the hit-server cache and for distributing objects to clients. Multiple, different miss-servers can be combined with a single hit-server or with multiple hit-servers (see Section 5).
Clients read and write objects by performing get and put operations on server objects. For example, HTTP's get and put are mapped to Lava's get and put by client libraries. The Lava operations also work on partial objects. This feature permits clients to download or modify arbitrary, selected parts of the object (i.e., as opposed to reading the entire object). As well, client libraries can implement file-system like access. Furthermore, objects can have object-specific get and put operations supplied by the object creator. For example, a custom get can present an object in different formats based on the requesting client. Another example is HTTP post: A combined putget operation sends the post data to the active object which then calculates the response and sends it back to the client as get data.
In fact, putget is the only existing operation from the hit-server's point of view. The put data is sent to the object which then delivers the get data. Pure get and put operations are implemented by putget using empty put or get parameters respectively. For better intuitive understanding, we will, however, always refer to pure get and put operations in the following sections.
In the remainder of this section, we develop the design of the server architecture. First, we describe an example server which demonstrates the interplay between the architecture components. Next, we analyze the application scenario to determine the requirements of the architecture. The last two subsections develop the design.
Next: An Example Server Up: High-Performance Caching With The Previous: Rationale
Vsevolod Panteleenko