CN103250141B - Networking client-server architecture structure in pre-read process - Google Patents

Abstract

For networking client-server architecture structure in carry out pre-reading in the method for process, divide into groups to read message by multiple unique sequence code mark (ID), wherein, each in described serial ID corresponds to the specific reading sequence be made up of all readings and pre-read request that relate to the particular memory section read continuously by the thread of the execution in client application.Storage system uses sequence id value to identify and filter and out-of-dately when being received by storage system pre-reads message, because client application moves, to read different memory paragraphs.Substantially, when its sequence id value is more late than the most recent value seen by storage system, message is abandoned.Serial ID is stored the pre-reads data that system is used for determining to be loaded into the correspondence pre-read in high-speed cache.

Description

Read-Ahead Processing in Networked Client-Server Architectures

technical field

The present invention relates generally to computers and, in particular, to read-ahead processing in a networked client-server architecture in a computing storage environment.

Background technique

When performing sequential read operations, the read-ahead mechanism improves the efficiency of the read process by performing a background read-ahead operation that loads data from the storage device into a memory-based cache, and then, on subsequent read operations, directly Read this data from cache. This enables efficient use of storage channels and devices, balancing I/O access over time, thus increasing the efficiency of the overall read process. Specifically, when a read operation is processed, rather than waiting to retrieve the data from the storage device, the data is generally already available in the read-ahead cache, since cache accesses (usually memory-based) are faster than I/O accesses Some, so the whole reading process is more efficient.

Contents of the invention

Generally optimizes the read-ahead mechanism for sequential read use cases. In the architectures considered in the various embodiments presented below and in the claimed subject matter, several factors may reduce the efficiency of the read-ahead mechanism. Primarily, due to the assumption that messages can be reordered as they pass through the network, the order in which messages are received at the destination will differ from the order in which they were generated and sent. This may cause read and read-ahead messages sent consecutively by the client to be received by the storage system out of order. Specifically, these messages may appear to have gaps and post-read behavior. These two behaviors may reduce the efficiency of the read-ahead mechanism operating in the storage system, since in such cases it is more difficult to determine which data is most beneficial to reside in the storage system's read-ahead cache.

Additionally, as a client application moves from reading one storage segment to another, a read-ahead message issued by the client for a previous segment may occur after the read and read-ahead messages associated with the following segment have already been read. Arrives at the storage system after processing by the storage system. Processing outdated messages associated with previous segments is inefficient because such processing is resource intensive. Furthermore, processing such stale messages may shift the read-ahead mechanism operating in the storage system to previous segments, which also reduces the efficiency of the read process.

In view of the foregoing, mechanisms that address the above challenges are needed. Accordingly, embodiments are provided for read-ahead processing by a processor device in a networked client-server architecture. Read messages are grouped by a number of unique sequence identifications (IDs), where each of the sequence IDs corresponds to a specific read sequence including the A thread of execution sequentially reads all read and read-ahead requests related to a particular memory segment. The storage system uses the sequence ID value to identify and filter read-ahead messages that are out of date when received by the storage system because the client application has moved to read a different storage segment. Basically, a message is discarded when its sequence ID value is later than the most recent value that has been seen by the storage system. The sequence ID is used by the storage system to determine the corresponding read-ahead data to be loaded into the read-ahead cache maintained by the storage system for each client application read session, where the read-ahead cache is logically partitioned into Front and back logically contiguous buffers for data processing, when advancing the data content of the read-ahead cache, the data is loaded into the slave The offset of the beginning of the following logical buffer is one byte after the end of the previous logical buffer. The read-ahead cache location in the data segment being read uses the above extensive Going forward in the method described, read requests are processed from the contents of the cache, or retrieved from storage (if the data they reference is not fully contained in the cache). When identifying a new sequential read stream, again derived by observing the incoming and maintained values of the sequence ID, the location of the cache in the data segment being read is modified based on the offset of the incoming read request , and the requested data is served from the cache.

In addition to the foregoing exemplary method embodiments, other exemplary system and computer product embodiments are provided that provide related advantages.

Description of drawings

Embodiments of the invention will now be described, by way of example only, with reference to the accompanying drawings, in which:

Figure 1 illustrates an exemplary read-ahead architecture in a computing storage environment;

Figure 2 shows a gap in a sequential read stream;

FIG. 3 illustrates an exemplary method for processing a read request that takes into account incoming and maintained sequence ID values;

FIG. 4 illustrates an exemplary method for processing a read request taking into account incoming and maintained sequence ID values and farthest offset values;

Figure 5 shows an exemplary calculation of the update data range for a read request using the furthest offset;

Figures 6 and 7 illustrate exemplary layouts of logical buffers in physical buffers implemented as read-ahead caches;

FIG. 8 shows exemplary conditions for triggering the advancement of the data content of the logical buffer first depicted in FIG. 6 based on a predetermined threshold;

FIG. 9 illustrates an example method for processing incoming read requests using a cache buffer; and

Figure 10 illustrates exemplary hardware suitable for implementing aspects of the following claimed subject matter.

Detailed ways

In the embodiments shown below, a networked client-server architecture is considered, where client applications issue read requests for data stored in a storage system (in this architecture, a server). Client applications and storage systems are attached through the network. FIG. 1 shows an exemplary such networked client-server architecture 10 . The client system 12 includes a client application 14 where read requests are issued through a client agent 20 that resides locally (ie, on the same processor) relative to the client application and uses a read-ahead cache 18 . Client agent 20 is a proxy of storage system 26 on the processor running client application 14 . Client agent 20 (not a client application) communicates with storage system 26 over network 28 .

Client agent 20 and storage system 26 communicate over network 28 using messages (eg, read and read-ahead requests 22 ). As is generally assumed for networks, it is assumed that in this architecture messages 22 can be reordered when passing through the network with respect to the order in which they were generated. In architecture 10, both client agent 20 and storage system 26 may apply their own read-ahead mechanisms. That is, the client agent 20 may generate read-ahead operations based on read requests issued by the client application 20 and store the read-ahead data in its own cache 18 . Additionally, storage system 26 may also generate read-ahead operations based on read requests 22 received from client agents 20 and store the read-ahead data in private cache 24 . Storage system 26 utilizes storage network connectivity 30 to send read and read-ahead requests 32 to storage devices 34, as shown.

While it is assumed that read requests issued by client applications 14 are generally sequential (hence, in this context, the advantage of the read-ahead mechanism), high-level read patterns by client applications are assumed to be random. An example of such a read pattern would be an application that reads a relatively large section of data from multiple storage entities (eg, files) (each stored independently in the storage system) using sequential read operations of smaller sections.

As mentioned above, the read-ahead mechanism is generally optimized for sequential read use cases. In the architecture 10 considered in the illustrated embodiment, several factors may reduce the efficiency of the read-ahead mechanism. Primarily, due to the assumption that messages can be reordered when passing through the network, messages may be received at the destination in a different order than the order in which they were generated and sent. This can cause read and read-ahead messages issued consecutively by the client agent to appear out of order when received by the storage system. Specifically, these messages may appear to have gaps and read-behind behavior. These two behaviors may reduce the efficiency of the read-ahead mechanism operating in the storage system, since in such cases it is more difficult to determine which data is most beneficial to reside in the storage system's read-ahead cache.

Also, again as mentioned above, as a client application moves from reading one storage segment to another, read-ahead messages issued by the client agent for previous segments may be associated with the following segment The read and read-ahead messages arrive at the storage system after they have been processed by the storage system. Processing outdated messages associated with previous segments is inefficient because such processing is resource intensive. Furthermore, processing such stale messages may shift the read-ahead mechanism operating in the storage system to previous segments, which also reduces the efficiency of the read process.

The illustrated embodiments serve to effectively address the above challenges. In the mechanisms of the illustrated embodiments, each read and read-ahead message sent from a client agent to a storage system expresses what will be referred to herein as a sequence ID value in a particular read sequence to group read messages such that all read and read-ahead requests associated with a particular memory segment being read consecutively by threads of execution in the client application are assigned the same unique sequence ID value and are thus grouped in Together. The storage system uses the sequence ID value to identify and filter read-ahead messages that are out of date when received by the storage system because the client application has moved to read a different storage segment. Broadly, a message is discarded when its sequence ID value is later than the most recent value that has been seen by the storage system.

The implementation of its read-ahead mechanism at the client agent involves generating read-ahead requests on each iteration covering all data needed to load into its read-ahead cache, without regard to previously issued read-ahead requests or to the In the case of a response to a read-ahead request sent or sent, the mechanisms of the illustrated embodiments allow the storage system to efficiently handle such a read-ahead request. This approach taken for the implementation of the client agent simplifies its implementation and ultimately enables the storage system to ensure that read accesses imposed to the storage device through its read-ahead mechanism are in reality serialized with respect to their offsets , which enhances the effectiveness of the read-ahead mechanism used by the storage system. In this approach, read-ahead requests generated by client agents can overlap in their data ranges, which in turn requires the storage system to also filter and modify read requests based on their requested data ranges.

In the following description, a read session associated with a thread of execution in a client application is referred to as a "client application read session". According to the mechanism of the illustrated embodiments, the storage system maintains for each client application read session the current furthest offset it processes in the data segment being read (in addition to the maintained sequence ID value ). In general, if the sequence ID value of the read request specified by the message is equal to the maintained sequence ID value, and the end offset of the received read request is less than or equal to the furthest offset maintained, the Discard incoming messages. If the sequence ID values are equal, and the end offset of the read request is greater than the farthest offset, the farthest offset is modified to be the end offset of the read request, and as the previous value from the farthest offset Add a byte starting and ending at the new value of the farthest offset to calculate the range of data read and sent to the client agent.

The storage system maintains a read-ahead cache for each client application read session, and uses the incoming and maintained values of the sequence ID to determine the data content to be loaded into the read-ahead cache. The physical buffers that make up the read-ahead cache are logically partitioned into two buffers that are always logically contiguous with respect to relative offsets in their data. Each of the logical buffers, regardless of their layout in the physical buffer, may be a first logical buffer in terms of their offset in the data, and then the other buffer is a second logical buffer. The data content in the buffer may advance according to the manner in which a read request of the client application read session advances. The data content of the buffer can only be moved forward in the data segment being read, and not tracked backwards. Advancement is triggered by exceeding a threshold on the number of read requests whose end offset exceeds a threshold offset in the second logical buffer, where the latter offset is based on the percentage of the data range covered by the second logical buffer to define. When such advance is activated, the start offset of the first logical buffer is set to the end offset of the second logical buffer plus one byte, and then the data is loaded into the newly defined second logical buffer.

When processing incoming read requests, the data contents in the two logical buffers are treated as contiguous data segments within a single buffer. In one embodiment, incoming read requests may be processed using the following method, as briefly described so far. As long as the continuous read stream, derived by observing the incoming and maintained values of the sequence ID, is maintained by the client application read session, the position of the buffer in the data segment being read is only used as described above. Broadly describes the methods to modify, read requests to be processed from the contents of the buffer, or retrieved from storage (if the data they refer to is not completely contained in the buffer). When identifying a new sequential read stream, again derived by observing the incoming and maintained values of the sequence ID, then the position of the buffer in the data segment being read, based on the offset of the incoming read request to modify, and the requested data is provided from the buffer.

In sending data requested by a read operation to the client agent, the storage system divides the returned data into non-overlapping segments and sends each segment in a separate network message. The storage system sends these response messages in parallel through multiple threads of execution and utilizing multiple network connections (ie, each response message may be sent using a different network connection), thus balancing the response messages over the network connections. Due to this approach, network bandwidth usage between the storage system and the client agent is significantly improved. The client agent collects the response messages sent by the storage system and composes the data for read and read-ahead requests from the data segments expressed in the response messages. Since the network bandwidth is better used with the above method, the overall read performance is enhanced.

When a client application read session moves to read a different storage segment, and if these messages are received in the storage system after the messages associated with the next segment have already been processed by the storage system, the Pre-read messages may become outdated. According to the mechanisms of the illustrated embodiments, such messages can be filtered at the storage system using the following methods.

Each read and read-ahead message sent from the client agent to the storage system expresses a sequence ID value that groups read messages in a specific read sequence so as to be contiguous with the thread of execution being executed by the client application All read and read-ahead requests associated with a particular bucket being read are assigned the same unique sequence ID value and are therefore grouped together. There is an order relationship between sequence ID values. Sequence ID values are generated by the client agent independently for each client application read session and allow identification of the different memory segments being read consecutively by the session. Read and read-ahead requests are associated with a specific sequence ID value, as long as the sequence ID value is not modified based on client agent logic specified next.

In one embodiment, the client agent generates a new sequence ID value for a client application read session when (1) there is no previous sequence ID value for the session, or (2) a new sequential read stream is initiated by the session . In one embodiment, a new sequential read stream can be identified by observing gaps (forward gaps or backward gaps) in the current read stream, as shown in Figure 2 below. Specifically, a gap exists when the difference between the start offset of the new read request and the end offset of the most recent read request differs by one byte (this difference can be positive or negative). The movement of different data entities (eg, different independent files) in the read session read memory is observed, and new sequential read streams are also identified. Such events are identified by observing the session using the new identifier of the memory entity.

FIG. 2 depicts an exemplary range 50 in a particular data segment being read, showing gaps in the sequential read stream. The data range for the next read request is exemplified as the data range 54 preceding or following the data range 56 of the most recent read request. In the first case the read request creates a backward gap 52 and in the second case the read request creates a forward gap 58 .

Referring now to FIG. 3 , there is shown an exemplary method 70 for processing read requests by a storage system, applying read-ahead logic and taking into account incoming and maintained sequence ID values. For each client application read session, the storage system maintains the current sequence ID value. The current sequence ID value is initialized to a null value. For a newly received read request associated with a client application read session (step 74): If there is no previous sequence ID value for this session (step 76), or if the received sequence ID value is greater than the maintained value update (step 78), the maintained value is set to the value sent with the new read request (step 80), and the read request is further processed (step 82); if the received sequence ID value is equal to the maintained value ( Again, step 78), the maintained value is not changed, and the read request is further processed (step 82); if the received sequence ID value is later than the maintained value (again, step 78), the associated read is discarded request and its serial ID value (step 84). Method 70 then ends (step 86).

In one embodiment, the client agent maintains a read-ahead cache for each client application read session to efficiently process read requests issued by the session. The client agent generates read-ahead requests to load data into its read-ahead cache. These requests are generated and their responses from the storage system are processed asynchronously (in the background).

In one possible embodiment, the client agent records the furthest offset to which it issued a read-ahead request, and further generates additional read-ahead requests from this offset. In this embodiment, such read-ahead requests will not overlap in their data extents, so the storage system processes incoming read requests according to their extents without having to filter or modify read requests due to overlapping extents.

In another alternative embodiment, the client agent generates read-ahead requests each iteration covering all data needed to be loaded into its read-ahead cache, regardless of previously issued read-ahead requests or requests for data currently being read-ahead. Generated or sent in response to a read-ahead request. This approach simplifies client proxy implementation and results in read-ahead requests generated by client proxies that may overlap in their data ranges. This requires storage systems to also filter and modify incoming read requests based on their requested data extent. As a result of this processing, the storage system can ensure that read accesses imposed to the storage device through its read-ahead mechanism are in reality serialized with respect to their offsets, thus enhancing the read-ahead used by the storage system effectiveness of the mechanism. In this method, the storage system filters and modifies read requests using the following method as shown in Figure 4 below.

FIG. 4 illustrates an exemplary method 90 for processing read requests by a storage system that takes into account incoming and maintained sequence ID values and farthest offset values. The storage system maintains for each client application read session the farthest offset it currently processes in the data segment being read. This value is initialized to null. This value is maintained in addition to the sequence ID value maintained. For a new read request received from a client application read session (step 94), if the read request's sequence ID value is equal to the maintained sequence ID value (step 98), then: if the read request's end offset is less than or equal to the farthest offset (step 100), the request is discarded (because the requested range has already been processed and sent to the client agent) (step 108). If the end offset of the read request is greater than the farthest offset (again, step 100), then the farthest offset is modified to be the end offset of the read request (step 102), and as The range of data read and sent to the client agent is calculated by adding the previous value to the range starting with a byte and ending at the farthest offset to the new value (step 104). In Figure 5 below, this calculation 120 is shown, where for an exemplary data range 122 for a read request with a start offset 124 and an end offset 132, and the previous value 126 of the farthest offset, results in The updated data range 128 of the read request ends at the new value 130 of the farthest offset.

If the sequence ID value of the read request is greater than the maintained sequence ID value (again, step 98), or if there is no previous sequence ID value for this session (step 96), the maintained sequence ID value is set to be the same as the new read sequence ID value. The value sent together with the request (step 110), the farthest offset is set as the end offset of the new read request (step 112), and the read request is further processed without any changes to its range (step 106). If the read request's sequence ID value is less than the maintained value (again, step 98), the associated read request and its sequence ID value are discarded (again, step 108). Method 90 then ends (step 114).

In one embodiment, the storage system maintains a read-ahead cache for each client application read session. The following is an exemplary method for determining data content to be loaded into a read-ahead cache, and using the cache to handle read requests. The physical buffer constituting the read-ahead cache is logically partitioned into two buffers whose data contents are determined using the following method. Two buffers are always logically contiguous with respect to their associated offsets in their data. That is, the start offset of the second logical buffer always starts one byte after the end offset of the first logical buffer. Each of the logical buffers, regardless of their layout in the physical buffer, may be a first logical buffer in terms of their offset in the data, and then the other buffer is a second logical buffer. Such partitions 140, 150 of exemplary data segments 148, 158 are shown in Figures 6 and 7 below as cases (A) and (B), respectively. The physical buffers 142, 152 are partitioned into first and second logical buffers 144, 146 and 154, 156 as shown.

Initially, when both logical buffers are empty, and when processing the first read request in a client application read session, the following exemplary method may be applied. The start offset of a buffer (eg, the one that is physically first among physical buffers) is set to the start offset of the read request. The start offset of the other buffer is set to the end offset of the first logical buffer plus one byte. The size of the data to be loaded into the buffers is their total size (ie, the size of the physical buffer). Data is loaded into two buffers (generally, with a single read operation to the storage device). Serves incoming read requests from the buffer.

The data content in the buffer can be advanced according to the way the read request of the client application read session is advanced using, for example, the following method. Advancing the data content in the buffer is done by setting the start offset of the first logical buffer to the end offset of the second logical buffer plus one byte. This toggles between the first and second logical buffers. Then, data is loaded into the current second logical buffer (formerly the first logical buffer).

A trigger for advancing the data content of a buffer using the exemplary method specified above is that the number of read requests whose ends are offset by more than an offset threshold exceed a threshold for the number of read requests. Whenever the data content of a logical buffer changes (ie, the first and second logical buffer switch), the offset threshold is recalculated, with its value associated with the percentage of the data range covered by the second logical buffer. In our approach, this percentage is 50%, meaning that when a read request starts referencing the second half of the second logical buffer, the data content of the first logical buffer has a low probability of being accessed further, so the first The logical buffer advances and becomes the second logical buffer. In one embodiment, the threshold number of such read requests is two. These thresholds 166 for an exemplary data segment 172 and the conditions used to trigger the advancement of the data content of the buffers 168, 170 are shown in FIG. The above read request 162), as shown in the figure.

The loading of data into the newly defined second logical buffer is done in an asynchronous (background) process with respect to the processing of the read request in the process of advancing the data content of the buffer. If any read request must access data that is in process of being loaded into the second logical buffer, this read request is blocked (using a synchronization mechanism) until the data is loaded and available in the second logical buffer.

When processing an incoming read request, the data content in the two logical buffers is treated as a coherent data segment within a single cache buffer. In one embodiment, incoming read requests may be processed using the following method 180 shown in FIG. 9 . Method 180 begins (step 182 ) by receiving a read request (step 184 ). If the cache buffer is empty (step 186), the data is loaded into the two logical buffers (step 188) using the previously described method, and the data for the read request is provided from the cache buffer (step 196 ).

If the cache buffer is not empty (again, step 186), and if the read request's start and end offsets are within the cache buffer's offset (step 190), then the read request is served from the cache buffer data (again, step 196). If the sequence ID of the read request is greater than the current sequence ID (step 192), then a flag is set indicating that the cache buffer will be reset on the first consecutive read request that exceeds the bounds of the cache buffer (as described below Specified). The current sequence ID is set to the sequence ID of the read request (step 194). If the sequence ID of the read request is less than the current sequence ID (again, step 192), then the read request has been discarded by the previously described sequence ID masking.

If the cache buffer is not empty (again, step 186), and if the read request's offset exceeds the cache buffer's offset (again, step 190), and if the read request's sequence ID is equal to the current sequence ID , and the flag indicating that the cache buffer is reset is turned off (indicating that it is still the same sequential read stream) (step 198), the data referenced by the read request is generally retrieved from the storage device, with the following exceptions. (1) If a portion of the data referenced by the read request is present in the cache buffer, this portion can be served from the cache buffer, and (2) if the current read request triggers the cache buffer's data modification in the content, or if such a modification is already in progress, and if the data it references would exist in the modified data content of the cache buffer, the read request may block until the cache buffer's Updated data content is loaded (step 200). Read requests that retrieve data content behind the cache buffer from the storage device (specifically, retrieve parts of them that are not present in the cache buffer) from the storage device are implied above, and never wait for the cache buffer Modifications in the content of the (always forward).

If the sequence ID of the read request is greater than the current sequence ID or the flag indicating that the cache buffer is reset is on (indicating that this is a newly read stream) (step 198), then the following method is used to update the data content of the cache buffer. The start offset of one logical buffer is set to the start offset of the read request; the start offset of the other logical buffer is set to the end offset of the first logical buffer plus one byte; read to buffer is their total size; and then the data is loaded into the cache buffer (using a single read request to the storage device) (step 202). The flag indicating that the cache buffer is reset is turned off (again, step 202). The read request is served from the cache buffer (step 196). Finally, if the sequence ID of the read request is less than the current sequence ID, the message is filtered by the preceding process on receipt (described previously). Method 180 then ends (step 204).

In sending data requested by a read operation to the client agent, the storage system divides the returned data into non-overlapping segments and sends each segment in a separate network message. The storage system sends these response messages in parallel by executing multiple threads and utilizing multiple network connections (ie, each response message can be sent using a different network connection), thus balancing the response messages over the network connections. As a result, network bandwidth usage between the storage system and client agents is significantly improved. The client agent collects the response messages sent by the storage system and composes the data for read and read-ahead requests from the data segments expressed in the response messages. The overall read performance is enhanced since the network bandwidth is better used with the above mechanism.

FIG. 10 illustrates exemplary hardware 250 suitable for implementing aspects of the claimed subject matter below. In the depicted embodiment, an exemplary portion 252 of architecture 10 (FIG. 1) is shown. Portion 252 of architecture 10 is operable as a part of a computer environment in which the mechanisms of the previously illustrated embodiments can be implemented. It should be understood, however, that Figure 10 is exemplary only, and is not intended to assert or imply any limitation with respect to the particular architecture in which exemplary aspects of the various embodiments may be implemented. Many modifications may be made to the architecture depicted in Figure 10 without departing from the following description and the scope of the claimed subject matter.

Portion 252 includes processor 254 and memory 256 such as random access memory (RAM). Portion 252 may be operably coupled to a number of components not shown for convenience, including a display, keyboard, mouse, printer, etc. to present images, such as windows, to the user on a graphical user interface. Of course, those skilled in the art will recognize that any combination of the above components, or any number of different components, peripherals, and other devices, may be used with portion 252 .

In the illustrated embodiment, portion 252 operates under the control of an operating system (OS) 258 (e.g., z/OS, OS/2, LINUX, UNIX, WINDOWSMACOS) stored in memory 256 and interfaces with the user to accept input and commands and present results. In one embodiment of the present invention, OS 258 facilitates the read-ahead functionality according to the present invention. To this end, the OS 258 includes a prefetch module 264 that may be adapted to perform various processes and mechanisms in the exemplary methods described in the previously illustrated embodiments.

Portion 252 may implement a compiler 262 that allows an application program 260 written in a programming language such as COBOL, PL/1, C, C++, JAVA, ADA, BASIC, VISUALBASIC, or any other programming language to be converted to be readable by processor 254. fetched code. After completion, the application program 260 uses the relationships and logic generated using the compiler 262 to access and manipulate the data stored in the memory 256 of the portion 252 .

In one embodiment, instructions implementing the operating system 258, application programs 260, and compiler 262 are tangibly embodied on a computer-readable medium, which may include one or more fixed or removable data storage devices , such as compact drives, compact discs, hard drives, DVD/CD-ROMs, digital tapes, solid-state drives (SSD), and more. Further, operating system 258 and application programs 260 may include instructions that, when read and executed by portion 252, cause portion 252 to perform the steps necessary to implement and/or use the present invention. Application programs 260 and/or operating system 258 instructions may also be tangibly implemented in memory 256 . As such, the terms "article of manufacture," "program storage device," and "computer program product" as they may be used herein are intended to cover a computer program that can be accessed and/or operated on from any computer-readable device or medium.

Embodiments of the invention may include one or more associated software applications 260, including, for example, functionality for managing a distributed computer system comprising a network of computing devices, such as a storage area network (SAN). Accordingly, processor 254 may include one or more storage management processors (SMPs). Application 260 may operate within a single computer or as part of a distributed computer system comprising a network of computing devices. The network may encompass connections via a local area network and/or the Internet (which may be public or secure, for example, via a virtual private network (VPN) connection), or via a Fiber Channel SAN or other known network types as understood by those skilled in the art. One or more connected computers.

Those skilled in the art know that various aspects of the present invention can be implemented as a system, method or computer program product. Therefore, various aspects of the present invention can be embodied in the following forms, that is: a complete hardware implementation, a complete software implementation (including firmware, resident software, microcode, etc.), or a combination of hardware and software implementations, These may collectively be referred to herein as "circuits," "modules," or "systems." Furthermore, in some embodiments, various aspects of the present invention can also be implemented in the form of a computer program product embodied in one or more computer-readable media having computer-readable program code embodied therein.

Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples (non-exhaustive list) of computer-readable storage media include: electrical connection with one or more wires, portable computer disk, hard disk, random access memory (RAM), read only memory (ROM), Erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In this document, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device.

Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including - but not limited to - wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing. Computer program code for carrying out the operations of the present invention may be written in any combination of one or more programming languages, including object-oriented programming languages—such as Java, Smalltalk, C++, etc., including conventional A procedural programming language—such as the "C" programming language or a similar programming language. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. Where a remote computer is involved, the remote computer may be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (such as via the Internet using an Internet Service Provider). connect).

The present invention has been described above with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart and/or block diagrams, and combinations of blocks in the flowchart and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine such that when executed by the processor of the computer or other programmable data processing apparatus , producing an apparatus for realizing the functions/actions specified in one or more blocks in the flowchart and/or block diagram.

These computer program instructions can also be stored in a computer-readable medium, and these instructions cause a computer, other programmable data processing apparatus, or other equipment to operate in a specific way, so that the instructions stored in the computer-readable medium produce information including An article of manufacture of instructions that implement the functions/actions specified in one or more blocks in a flowchart and/or block diagram. It is also possible to load computer program instructions into a computer, other programmable data processing device, or other equipment, so that a series of operation steps are executed on the computer, other programmable device or other equipment, so as to generate a computer-implemented process, so that in The instructions executed on the computer or other programmable apparatus provide a process for implementing the functions/operations specified in the flowcharts and/or blocks in the block diagrams.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or part of code that includes one or more Executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified function or action , or may be implemented by a combination of dedicated hardware and computer instructions.

Although one or more embodiments of the invention have been shown in detail, those skilled in the art will appreciate that modifications may be made to those embodiments without departing from the scope of the invention as set forth in the claims below .

Claims (16)

1. A method for prefetch processing by a processor device in a networked client-server architecture, comprising: Read messages are grouped by a plurality of unique sequence identifications (IDs), each of which corresponds to a read sequence, including memory segments being read contiguously by threads of execution in the client application related read and read-ahead requests; Using the sequence ID, filtering the outdated read messages by discarding one of the outdated read messages whose sequence ID is determined to be later than the maintained sequence ID; and The sequence ID is used to determine the corresponding read-ahead data to be loaded into the read-ahead cache. 2. The method of claim 1, wherein the read-ahead cache is logically partitioned into front and back logically contiguous buffers for data processing, and further comprising Read data is loaded into the following buffer starting at an offset approximately equal to the capacity of the preceding buffer. 3. The method of claim 2, further comprising initializing a client application read session for processing new read requests. 4. The method of claim 3, further comprising setting the maintained sequence ID to the received sequence ID if a previous sequence ID does not exist for the read session. 5. The method of claim 3, further comprising: if the received sequence ID is determined to be newer than the maintained sequence ID, setting the maintained furthest offset value to the new read request end offset. 6. The method of claim 3, further comprising: if the received sequence ID is determined to be equal to the maintained sequence ID, if the end offset of the new read request is less than and equal to the new read request If one of the farthest offsets requested is fetched, the new read request is discarded. 7. The method of claim 6, further comprising: if the received sequence ID is determined to be equal to the maintained sequence ID, setting the range of data to be read to the previous Add a range of values starting with a byte to end at the new value at the farthest offset, and send the range of data to the client agent. 8. The method of claim 3, wherein if the read-ahead cache is determined not to be empty when loading the read-ahead data: If the start and end offsets of the new read request are within the offsets of the read-ahead cache, and the received sequence ID of the new read request is greater than the maintained sequence ID, then at the first A flag is set on successive read requests indicating that a reset of the read-ahead cache is to occur, and If the start and end offsets of the new read request exceed the offset of the read-ahead cache, and the received sequence ID of the new read request is equal to the maintained sequence ID, and the mark, the read-ahead data is loaded into the read-ahead cache, and If the start and end offsets of the new read request exceed the offset of the read-ahead cache, and the received sequence ID of the new read request exceeds the maintained sequence ID and the flag is set , the start offset of one of the back and front buffers is set to the start offset of the new read request, and the other of the back and front buffers The start offset of is set to be approximately the end offset of the other of the rear and front buffers. 9. A system for read-ahead processing in a networked client-server architecture, comprising: A means configured to group read messages by a plurality of unique sequence identifications (IDs), each of the sequence IDs corresponding to a read sequence, including consecutive messages being executed by a thread of execution in a client application Read and read-ahead requests related to buckets read locally; a means configured to filter outdated read messages using the sequence ID by discarding one of the outdated read messages whose sequence ID is determined to be later than a maintained sequence ID; and An apparatus configured to use the sequence ID to determine corresponding read-ahead data to load into a read-ahead cache. 10. The system of claim 9, wherein the read-ahead cache is logically partitioned into front and back logically contiguous buffers for data processing, and further comprising Read data is loaded into the following buffer starting at an offset approximately equal to the capacity of the preceding buffer. 11. The system of claim 10, further comprising: means configured to initiate a client application read session for processing new read requests. 12. The system of claim 11, further comprising: means configured to set the maintained sequence ID to the received sequence ID if a previous sequence ID does not exist for the read session. 13. The system of claim 12 , further comprising: a means configured to set the maintained furthest offset value to The end offset of the new read request. 14. The system of claim 12 , further comprising: a means configured to, if the received sequence ID is determined to be equal to the maintained sequence ID, if the end offset of the new read request is less than sum is equal to one of the farthest offsets of the new read request, then the new read request is discarded. 15. The system as claimed in claim 14 , further comprising: a means configured to set the range of data to be read from the most The previous value of the furthest offset plus a range starting at the new value of the furthest offset, and sending the range of data to the client agent. 16. The system of claim 11 , further comprising: a means configured to, if the read-ahead cache is determined not to be empty when loading the read-ahead data: If the start and end offsets of the new read request are within the offsets of the read-ahead cache, and the received sequence ID of the new read request is greater than the maintained sequence ID, then at the first A flag is set on successive read requests indicating that a reset of the read-ahead cache is to occur, and If the start and end offsets of the new read request exceed the offset of the read-ahead cache, and the received sequence ID of the new read request is equal to the maintained sequence ID, and the mark, then load the read-ahead data into the read-ahead cache, and If the start and end offsets of the new read request exceed the offset of the read-ahead cache, and the received sequence ID of the new read request exceeds the maintained sequence ID and the flag is set , the start offset of one of the back and front buffers is set to the start offset of the new read request, and the other of the back and front buffers The start offset of is set to be approximately the end offset of the other of the rear and front buffers.