JPH09319652A - Look-ahead control method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To decrease the replacement of data locked aheard by a main memory with the other data. SOLUTION: When an operating system (OS) judges a read request from a user process to a secondary storage device as successive access, before looking ahead data following the data designated by that request, it is judged whether or not look-ahead is to be stopped. That judgement is executed so that these following data looked ahead in the cache area of the main memory can be prevented from being replaced with the other data. Namely, the data requested by this read request are already looked-ahead data (62), and it is judged whether these data are already replaced with the other data or not (63). When these two conditions are satisfied, look-ahead is wasted. Look-ahead added to this read request is not executed but a look-ahead stop flag is set (64) and concerning the following successive access, look-ahead is inhibited by this look-ahead stop flag.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for controlling a read-ahead operation for reading data from a secondary storage device into a cache area provided in a main memory for a processor before the data is requested.

[0002]

2. Description of the Related Art In many ordinary computer systems, reading of data requested by a user process from a secondary storage device or writing data to the secondary storage device is performed by a cache provided in a main storage by an operating system (OS). It is done through the area. As a typical operating system (OS) often used in workstations, X / Open Com
UNIX, which is developed and licensed by pany, is known. "The Design and Impl
element of the 4.3 BSD
UNIX Operating System ”,
Addison-Wesley Publishing
Company, Inc. Pages 29 to 37,
Pages 172 to 177, pages 191 to 193,
See pages 208 to 211, (1989) (hereinafter referred to as reference 1).

Under this OS, prefetching of data from the secondary storage device is also performed. That is, when the OS processes a read request from a user process, the OS determines whether the user process is sequentially accessing the same file, for example. If it is determined that the user process is making sequential access, the read request is executed, the I / O request issued next by the user process is predicted, and the predicted block read request is also asynchronously set to 2 Issued to the next storage device. Next, when the user process issues a read request for the prefetched data, the data is immediately transferred from the cache area to the user process. At this time, prefetch of the next data is also executed. This prefetching is executed in parallel with the processing of the read request requested by this user process. For example, "E
xtent-like Performance fr
oma UNIX File System ", Pro
ceedings of the Winter 19
91, USENIX Conference, No. 33
See pages 42 to 1991 (hereinafter referred to as reference 2).

[0004]

As a result of studies by the present inventors, in the prefetching method according to the prior art, the prefetched data may be replaced by other data before being used by the user process. I found that it was possible. When such replacement occurs, the prefetching itself becomes useless. Furthermore, if a large number of such useless prefetches occur, the read performance with respect to the secondary storage device deteriorates.

Specifically, if many user processes run simultaneously, many files for those processes are opened, and those user processes access those files sequentially at about the same time, The operating system may try to use more cache entries than the total cache entries. At this time, the above replacement occurs.

[0006] For example, page 208 of Ref. 1 has a range of 10 to 1000 depending on the amount of main memory available.
It is stated that any number of cache entries in between can be incorporated. Here, it is assumed that the number of cache entries is 1000. It is also assumed that the amount of data used by the user process for reading is 8 blocks. From the description in Reference Document 2, it is assumed that the amount of data to be prefetched at one time is 7 blocks. In the above OS, 2
The block stored in the next storage device is called a logical block, and here it is assumed that the size of the logical block is 8 kilobytes. Suppose there are 60 user processes, each of which simultaneously issues a read to a different file. Based on the above assumption, the number of cache entries used simultaneously is 900 (8 blocks x 60 files + 7
(Block × 60 files) entry. The number of entries does not exceed the assumed total number of cache entries of 1000. Therefore, in the assumed situation, it can be expected that the prefetched data remains on the cache until it is actually used.

However, when the number of files that are simultaneously opened for reading is larger, the number of cache entries that the operating system tries to use may exceed the total number of cache entries. For example, assume that the number of files read simultaneously is 120. The number of cache entries used at this time is 180
0 (8 blocks x 120 files + 7 blocks x 120
File). Comparing this number with the assumed number of entries in the cache, 1000, the required number of entries is larger than the total number of entries in the cache in the assumed situation. As a result, when the data of the logical block including the read data requested by the user process or the data of the logical block to be read in advance is stored in the cache, an empty entry or an entry holding the used data is stored in the cache area. Cease to exist. In the conventional cache entry management described in Reference 1, in such a case, even if the prefetched data has not been accessed by any user process, the entry holding the prefetched data is Used to hold data requested by other user processes. Thus, before the prefetched data is used,
It will be replaced with other data.

The inventors of the present invention have found that this problem occurs not only when the number of files read simultaneously is large, but also when the number of files to be read ahead is large for each file even when the number of files is relatively small. I found it. Based on the above assumption, the number of user processes that access the file at the same time is reduced to 60, while the amount of data to be read ahead is reduced to 16
If the number of cache entries used simultaneously increases to 1440 (8 blocks x 60 files + 1)
6 blocks x 60 files). This number of entries exceeds the assumed total number of cache entries of 1000. As a result, it can no longer be expected that the prefetched data will remain in the cache until it is actually used.

An object of the present invention is to provide a data read-ahead method capable of suppressing such read-ahead data from being replaced by other data before being used by a user process.

A more specific object of the present invention is to provide a data prefetching method that does not increase the occurrence of replacement of prefetched data with other data.

Another more specific object of the present invention is to provide a data prefetching method capable of preventing occurrence of replacement of prefetched data with other data.

[0012]

In order to solve the above problem, the prefetch control method according to the present invention determines whether the read request satisfies a predetermined prefetch stop condition before executing the prefetch. If the read request satisfies the above condition, the prefetching is stopped. Here, the condition is to prevent the subsequent data from being replaced by other data that will be read later from the secondary storage device into the cache area when the subsequent data is read ahead. Is the condition.

In a more specific aspect of the present invention, when it is detected that already prefetched data has been replaced in the cache area by any other data before being transferred to the user process, After that, prefetching is stopped.

In another more specific aspect of the present invention, the allocation of the cache area is controlled so that the cache area holding the prefetched data is not allocated to other data. When there is no cache area to be allocated to the prefetch data, the prefetch is stopped.

[0015]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The data prefetching method according to the present invention will be described in more detail with reference to some embodiments shown in the drawings. In the following, the same reference numbers represent the same or similar items. Further, in the second and subsequent embodiments of the invention, only the differences from the first embodiment of the invention will be described.

<First Embodiment of the Invention> (1) Outline of Operation In FIG. 1, a computer system is composed of a processor 1 which is a host device and a magnetic disk storage device 2 which is a secondary storage device. The secondary storage device may actually be composed of a plurality of magnetic disk storage devices, or may be composed of array disks. Processor 1
Is composed of an instruction unit for executing instructions, a main memory, a storage control device for controlling the main memory, etc., but these circuits are not shown for simplification. Instead, the figure
One running user process 3 and operating system (hereinafter OS) in the block of the processor 1.
4 is shown. Although a large number of user processes are actually running on the processor 1 at the same time, only one user process 3 is shown in the figure for simplification. The number of these user processes is much larger than 1, for example, about 60.

When the user process 3 issues a read request 5 for a file in the secondary storage device 2,
The OS 4 executes the read process 6. Thus, the logical block data (request target block data) 2a including the data requested by the user process 3 is read from the magnetic disk storage device 2 and stored in the cache area 10 managed by the OS 4. The data requested by the user process (request target data) in the request target block data 2a is the user buffer 8 prepared by the user process 3.
Is forwarded to The read processing 6 determines whether or not the prefetch corresponding to the read request 5 is executed in parallel with the execution of the read request. When the prefetch is executed, the data of a plurality of logical blocks is prefetched. It is assumed that the number of prefetch logical blocks is considerably larger than 1, for example, about 7 blocks. The pre-read logical block data (pre-read target block data) 2b is
It is stored in the cache area 10. As a result, the read process related to the read request from the user process 3 ends.

The read processing 6 determines whether or not the read request 5 is a sequential read request in order to determine whether or not to perform prefetching. What is characteristic of this embodiment is that even if this read request is a sequential read request, the prefetch of the data subsequent to the data requested by this read request is not executed immediately, but rather by the prefetch stop determination processing 47. , Is to determine whether or not prefetching should be stopped. Specifically, in the stop determination process 47, this read request is a read request for the data that has already been read in advance in the cache area 10, and the read-ahead stop condition that the data has been replaced by other data is set. Whether or not it is satisfied is determined. When this condition is satisfied, prefetching of data subsequent to the data requested by this read request is stopped. further,
Prefetching is also stopped for subsequent sequential read requests for this file.

As will be described later, in the management method of the cache area 10 adopted in this embodiment, the fact that this condition is satisfied means that the prefetched data is stored in other data before being used by the user process. This look-ahead is wasted because it indicates a replacement. This condition is met when many files are open simultaneously and many user processes are issuing sequential read requests to those files. Therefore, in the present embodiment, when such replacement of the prefetch data with other data occurs, the prefetch is controlled so that the prefetch is not performed thereafter. Therefore, in the present embodiment, although the read-ahead data is replaced with another data once for one file, the same useless data read-ahead thereafter can be eliminated.

(2) File management in OS The OS 4 uses a known procedure except that the read-ahead stop determination process 47 is executed using some new information stored in the inode described below. Manage multiple files in. For example, see reference 1. Specifically, the user process 3 first issues an open system call to input / output a file. The OS globally manages a plurality of files held in the magnetic disk storage device 2 and a plurality of i including information for executing an access from any one user process to each one file.
It has a node 9 and a file descriptor table 181 provided for each user process.

When the OS opens the file requested by this system call, the OS creates the inode 9 for the file. Specifically, the OS reads the i-node stored in the magnetic disk storage device 2 into the main memory. Hereinafter, the term “i-node” used in this specification refers to an i-node read into the main memory. The OS then makes an entry 183 in the file table 182 known per se.
Is added, an entry is added in the file descriptor table 181 corresponding to the user process 3,
The contents of the entry added to this file descriptor table 181 are returned to. This content is called a file descriptor and consists of a pointer to the entry 183 added to the file table 182.

The inode 9 is similar to the known inode,
File management information for managing the file such as the file owner, access right, and file size, and an index to the logical block for accessing the logical block storing the data on the magnetic disk storage device 2. Have. Unlike the known i-node, the i-node 9 of the present embodiment also has a final access position 22, a final pre-read position 23, and a pre-read stop flag 24 for the pre-read stop determination process 47. The final access position 22 and the final look-ahead position 23 represent the position to which the same user process 3 finally issued an access request for the corresponding file and the position to which the pre-reading process was last performed for that user process 3. The prefetch stop flag 24 is set when prefetch is prohibited for the corresponding file.

The file table 1 as well as the known file table
The entry 183 of 82 is the number of references from the process, the starting point of the next input / output and the byte offset in the expected file, the access right (read / write) to the opened process, the inode 9 of the opened file. Contains a pointer to. This byte offset determines the next read / write position within the file. For example, when reading or writing from the beginning of the file when opening the file, the byte offset in the file table is 0.
Is set to If the user process opens the file in the additional write mode, the byte offset in the file table is set to the size of the file. Subsequent input / output requests from the user process 3 are made using read or write system calls. At this time, these system calls include the file descriptor, the buffer address in the user process space, and the data size as arguments. That is, read or writ
The e system call does not specify the offset to read or write in the file. When the file data is read and written, the byte offset in the file table 182 is updated by the size of the transferred data. The byte offset in the file table can also be directly set by the user process by the lseek system call.

The advantage of having a file byte offset in the file table 182 is that multiple user processes can share the byte offset for the same file, or have different byte offsets. That is, it is possible to determine the file descriptors of the plurality of entries so that the plurality of entries belonging to the plurality of file descriptor tables 181 for the plurality of user processes point to one entry of the file table 182. In this case, when performing file I / O from those user processes, these user processes can share the same byte offset within this shared entry. Further, a plurality of entries belonging to the plurality of file descriptor tables 181 for the plurality of user processes are the file table 1
82 determine the file descriptors of the plurality of entries in the file descriptor table 181 to point to different entries 183, and further, these entries 183 in the file table 182 point to the inode 9 for a file. Thus, it is possible to determine the pointer to the inode in the different entry in the file table 182. In this case, these user processes can have different byte offsets for the same file.

(3) Data read processing 6 When the user process 3 issues a read request 5,
The OS 4 executes the read process 6. User process 3
The number of blocks required by the above is generally a number considerably larger than 1, and here it is assumed that it is about 8. Referring to FIG. 3, in the process 6, first, a read request from the user is converted into a file block number which is a relative position of a block in the file (step 41). further,
From the file name specified by the read request 5 from the user process 3, the inode of the corresponding file is determined.
Further, the file block number indicating the position of the block (file block) in the file designated by the read request 5 is converted to the logical block number indicating the storage position of the file block on the magnetic disk storage device 2 by the inode 9
It is transformed using the information in (step 42).

Next, a read request for the requested logical block data including the data specified by the read request from the user process is asynchronously issued to the magnetic disk storage device 2 (step 43). Before issuing the read request for the request target logical block data to the magnetic disk storage device 2, a hit check is performed on the cache 10 by a known method for the read request for the request target logical block data. Specifically, the hit check is performed by the following method. Cache entries with valid data reside on individual hash queues (not shown) that are hashed as a function of logical block number. The OS finds the logical block storing the requested data and traces the hash queue based on the logical block. If the logical block is found in the hash queue, the cache has been hit. If the cache 10 hits the read request, the data held in the hit cache entry is transferred to the user buffer 8 in the user process 3, and the asynchronous read request is not issued. If the cache 10 does not hit, the cache entry for holding the requested logical block data is searched from the cache 10 by the method described later.

Thereafter, it is judged whether this read request is a sequential read request (step 45). In the present embodiment, whether or not the sequential read request is made is determined by whether or not the current access position is the address position next to the final access position 22 (FIG. 1). Later steps 52 and 53
As will be described in Section 3, every time the magnetic disk storage device 2 is accessed by a read request requested by any user process for the file corresponding to the inode 9, the last file accessed by that request The block number is written in the final access position 22. Here, when the read target block is composed of a plurality of blocks, the file block number of the last read block is written. As a result, this sequential access determination method is performed in file units independently of the number of processes to access. Therefore, two user processes have different byte offsets,
If alternating blocks are accessed consecutively in the same file, then these accesses are not considered sequential.

When it is determined in step 45 that the current read request is not sequential access, the final prefetch position 23 is updated with the file block number of the requested block (step 52). When the requested block consists of multiple blocks, the file block number of the last block of those blocks is used for this update. This update is performed so that the stop determination process 47 can be executed for the sequential access when the sequential access occurs later. On the other hand, when the access is a sequential access, the prefetch stop determination processing 47 is executed to determine whether or not the prefetch is executed. Therefore,
Prefetch is not performed directly for sequential access. The prefetch stop determination processing 47 is a characteristic part of the present embodiment, and its details will be described later.

When it is determined in the prefetch stop determination processing 47 that the prefetch is stopped, the above-described step 52 is executed. When it is determined in the prefetch stop determination process 47 that prefetching is performed, the size of the data to be prefetched (the number of prefetch logical blocks) is determined (step 46). This determination is made as follows each time the reading process 6 is executed. When the number of pre-read logical blocks for the file to be accessed falls below a predetermined threshold, the number of pre-read logical blocks is set to an appropriate number that is predetermined by the system, and this set of multiple Pre-reading of logical blocks is performed collectively. When the number of pre-read logical blocks exceeds the threshold value, the number of pre-read logical blocks is set to 0, and pre-read in the current read processing is suppressed.
In general, in the magnetic disk storage device 2 or the like, the larger the amount of data input / output at one time, the more efficient the transfer.
That is, when a plurality of blocks are read together, the OS
The number of I / O request issuance processes and I / O completion interrupt processes is also reduced, which reduces the I / O processing time per data amount. The technique described on page 38 of Reference 2 can be used to collectively read out a plurality of blocks.

As described above, it is assumed that the number of prefetch logical blocks is considerably larger than 1, for example, 7 blocks. In this case, the threshold value of whether or not to perform pre-reading in this read processing is set to a number of 7 or less. For example, if the threshold value is set to 1, the prefetch of the next 7 blocks is started when the data of the final prefetched logical block is requested by the user process.
Further, for example, if the threshold value is set to 7, when the data of the first prefetched logical block is the target of the user process, prefetching of the next 7 blocks of the prefetched final logical block is started. In order to execute the prefetch of the set number of logical blocks of data, a read request of the prefetch target logical block is asynchronously issued to the magnetic disk storage device 2 (step 48). Before issuing the read request for the prefetch target data, a cache entry for holding the prefetch target data is secured by a method described later.

Further, the final prefetch position 23 is updated with the file block number of the prefetch target block (step 49). When the prefetch target block consists of a plurality of blocks, the file block number of the last prefetched block is used for this update. further,
The last access position 22 is updated with the last read file block number (step 53). Step 43
Data of the logical block requested by the user process executed in
It is waited for the data to be read out to 0 (step 50). When this requested logical block data is read, it is stored in the block data area of the cache entry searched before the execution of step 43, as will be described later. Of the block data, the data requested by the user process is transferred to the user buffer 8 (step 51). When this prefetch target block is read, although not shown here, as will be described later, step 4
The data is stored in the block data area of the cache entry secured before the execution of 8.

(4) Cache Management The request target data 2a and the prefetch target data 2b are managed in the cache area 10 as follows. A plurality of cache entries are stored in the cache area 10. Each cache entry includes a cache entry header 81 and a block data area 82, as shown in FIG. The cache entry header 81 includes a cache entry management information, a pointer 83 to a block data area pointing to the block data area 82, a pointer for forming a hash queue, and one of a plurality of free lists described later. Pointers 84 and 85 pointing to the subsequent cache entry and the subsequent cache entry,
It consists of a pointer 87 to the hash queue and the like. The hash queue is used for fast retrieval of cache entries. This hash queue is created in step 43 above.
Used to check for cache hits, as described in. One cache entry is used for one logical block. Therefore, the maximum size of the logical block data area 82 is the same as the logical block size. As described above, when a plurality of logical blocks are read collectively, as many cache entries as the number of logical blocks are required.

When inputting and outputting certain logical block data, the OS allocates a cache entry to store the data of the logical block and holds the logical block data in the block data area. The plurality of cache entries are managed using a plurality of free lists. The free lists used in the present embodiment and the cache entry management method using them are basically the same as those described on page 208 to page 213 of the reference document 1.

Free lists related to the present embodiment include the longest unused (LRU) list, AGE list, and EMPTY.
It is a list. As shown in FIG. 6, LRU free list 3
10 comprises an LRU free list header 31 and a plurality of cache entries. Each cache entry is composed of the cache entry header 81 and the block data area 82 as described above. The cache entry header 81 is connected to the LRU free list header 32, and the cache entry header 81 is connected to the block data area 82. . The LRU free list 310 contains logical block data requested by any user process, already transferred to the user process, and likely to be reused by that user process. LRU
The free list 310, as the name implies, manages multiple cache entries with the LRU algorithm. LR
When any cache entry is registered in the U free list 310, that cache entry is connected to the end of the LRU free list 310. When a new cache entry is needed to hold another logical block of data and any cache entry attached to the LRU free list 310 is retrieved, the LRU
The cache entry at the head of the free list 310 is fetched. As a result, the LRU free list 310 is L
Implement the RU algorithm.

The AGE free list 320 comprises an AGE free list header 32 and a plurality of cache entries.
The AGE free list 320 contains logical block data that is expected to be used in the near future or logical block data that has been requested by a user process, has already been transferred to that user process, and is unlikely to be reused by that user process. It The data in logical blocks expected to be used in the near future is typically prefetched data. A cache entry that holds data that has been used by the user process and is unlikely to be reused is A
The cache entry connected to the head of the GE free list 320 and holding the prefetched data is connected to the tail of the list. The judgment as to whether or not a certain data is likely to be reused can be made by a method known per se. See page 212 of ref. 1, for example. Further, for example, even if it is determined that the logical block data is not likely to be reused when the end of the data included in one logical block in the file that is sequentially accessed is terminated by the user process. Good. When only the data before the end of the data included in the logical block has been accessed, it may be determined that the logical block data may be reused.

The final EMPTY free list 330 is E
It is composed of the MPTY free list header 33 and a plurality of cache entries. The EMPTY free list 330 is a list of empty cache entries. The empty cache entry is an entry in which sufficient physical memory is not allocated in the virtual address space for the block data area. See page 211 of ref. 1, for example. Therefore, in FIG. 6, the block data area is not shown for convenience.

The cache entries registered in these free lists are managed as follows. Hereinafter, when registering a cache entry including a logical block in the LRU free list 310 or the AGE free list 320, it is simply referred to as registering the logical block, and when deleting the cache entry from the free list, the logical block is simply registered. May be said to be deleted. When any of the user processes issues a data read request, it is first checked whether or not the data of the logical block holding the user request target data designated by the request has been read in advance. Depending on the result of this check,
The cache management after that is different.

(A) When the data specified by the read request has not been pre-read yet (a1) When there is a cache entry on the EMPTY free list 330 Sufficient to hold the data of the logical block specified by the read request It is checked whether there is any free area in the cache area 10. If there is a sufficient free area, an area of a size necessary to hold the logical block data is secured from the free area, and the EMP
The cache entry header 81 registered in the TY free list 330 is fetched for the read request and points to the reserved area. When the request target data is read from the magnetic disk storage device 2, the request target data is written in the area. The requested data is transferred to the user buffer 8 for the requesting user process 3. Thus, cache area 1
That the data in 0 is transferred to the user process 3,
The data is called used by the user process 3. When the transfer of the data is completed, the data is said to be used.

After this transfer, it is determined by a predetermined known method whether or not a read request for the logical block data may be issued again by the user process. Thus, the possibility that a read request for the used data will be issued later from the same user process is called the possibility that the data will be reused. If it is determined that the data may be reused, the cache entry including the fetched cache entry header and the logical block data is connected to the end of the LRU free list 310. If it is determined that the data of the logical block is unlikely to be reused, the cache entry is connected to the head of the AGE free list 320.

(A2) When there is no cache entry in the EMPTY free list 330 The cache entries registered in the AGE free list 320 are searched sequentially from the head of this list. If any cache entry is registered in this list, that cache entry is deleted from this list. When this requested data is read from the magnetic disk storage device 2, this data is written in the block data area of the deleted cache entry. Thereafter, this data and this cache entry are processed in the same manner as in the above case (1a). If no cache entry is registered in the AGE free list 320, the LRU free list 310
The cache entry at the beginning of is removed from the list and is used. After that, it is the same as the case already described.

(B) When the requested data is already prefetched and a cache hit occurs. The hit cache entry registered in the AGE free list 320 is deleted from this list. The data of the logical block of the cache entry is transferred to the requesting user process. No data is read from the magnetic disk storage device 2. The subsequent processing is the same as that already described.

In the above cache management method, when the number of user processes for reading is relatively small compared to the total number of cache entries, or when the number of blocks read in one prefetch is relatively small, the following is performed. Works fine. That is, normally, there are a plurality of cache entries including data blocks that are not likely to be reused at the head of the AGE free list 320. When data read requests from various user processes occur, EMPT is issued for those data read requests.
A cache entry in the Y free list 330 or A
A plurality of cache entries including the data blocks that are not likely to be reused at the head of the GE free list 320 are used. Therefore, when the user process issues a read request for the data of the prefetched logical block connected to the end of the AGE free list 320 before the cache entries are exhausted,
The prefetched data will be effectively used.

However, if the number of processes for reading is relatively large compared to the total number of cache entries, or if the number of blocks read in one pre-read is relatively large, the following problem occurs. That is, before a read request requesting the data of the prefetched logical block connected to the end of the AGE free list 320 is issued by the user process, the EMPTY for the data read requests issued by various user processes. Free list 3
The cache entries in 30 or the plurality of cache entries including the above-not-reusable data block in the head portion of the AGE free list 320 may be used up. Therefore, the cache entry holding the prefetch data for the newly generated read request is also deleted from the AGE free list 320, and read from the magnetic disk storage device 2 for the new read request or another prefetch. Used to hold the data stored. In this way, the block data area holding the prefetch data is replaced by the request target block or another prefetch target block. As a result, prefetching itself becomes useless.

(5) Read-ahead read stop determination processing 47 The read-ahead stop determination processing 47 detects whether or not such replacement has occurred, and if this replacement has occurred, the read processing 6 is executed. Access determination processing 45 of
Even if the read request is determined to be the sequential access in (FIG. 3), the execution of the prefetch is controlled so that the prefetch is not performed. In FIG. 4, determination is made based on whether the stop flag 24, which will be described later, has already been set in the inode 9 (FIG. 2) for the file to be accessed (step 61). If this flag 24 is set, the prefetching has already been stopped, so this prefetching stop determination processing 47 ends and step 52 (FIG. 3) is executed. Prefetch stop flag 2
If 4 is not set yet, it is determined whether the read request this time satisfies the prefetch stop condition as follows. First, it is determined whether or not the data of the request target block of the user process 3 has already been prefetched (step 62). The data of the requested block of the read request that is determined to be the sequential access is not prefetched yet when this sequential access is the first access of a series of sequential access to the same file. This determination is made based on whether or not the final prefetch position 23 stored in the corresponding i-node 9 is equal to or greater than the address designated by the current read request.

When the data of the requested block has not been prefetched yet, this stop determination processing 47 ends,
Step 48 (FIG. 3) is performed to perform the lookahead. When the request target data has already been prefetched, it is determined whether the prefetched data has been replaced by another read request target data (step 63). This replacement occurs when the data of the read request target exists in the cache area 10, that is, when the read request target data is in the cache area 10.
Is determined by whether or not hit. This hit check is performed by a method known per se.

If the replacement has not occurred, the stop determination processing 47 is terminated, and prefetching is executed in step 48 (FIG. 3). If this replacement occurs, it is determined that the cache entry for holding the request target block data or the prefetch target block data is insufficient, and the prefetch is stopped. That is, the prefetch stop flag 24 (FIG. 3) in the inode 9 is set, the stop determination process 47 ends, and the process 52 (FIG. 3) when prefetch is not executed is executed. When this flag 24 is set, subsequent prefetching of the file currently being accessed is prohibited by step 61. In this way, when the pre-read data is overwritten and the pre-read becomes useless, the pre-read for the file including the pre-read data can be stopped.

Similar to the above-mentioned assumption, the number of entries in the cache is 1000, the amount of data used by the user process for reading is 8 blocks, the number of user processes is 60, and each user process simultaneously It is assumed that read requests for different files are generated and the amount of data to be read ahead is 16 blocks. At this time, the amount of cache entries used to hold the request target data of the read request issued by each user process becomes 480 (8 blocks × 60 files), and the remaining 520 entries are replaced with the prefetched data. Only a reasonable number of user processes that do not occur will be allowed to read ahead. The appropriate number here is 520 entries / 16 blocks = 16, and prefetching is performed for this number of user processes, and prefetching is not performed for the remaining 28 user processes. In this way, 1000 cache entries can be efficiently used.

In the present embodiment, the replacement of the prefetched data with other data occurs once for some user processes in this manner, but the prefetched data can be replaced without changing the cache management algorithm of the prior art. Subsequent replacement of can be prevented. Note that the prefetched data is not always used in the future. Therefore, it is possible that the AGE free list 320 is filled with prefetched data that is unlikely to be used in the future. In this case, in the present embodiment, a large number of prefetched data registered in the AGE free list 320 is sequentially replaced by new request target data or prefetch target data, and thus such unnecessary prefetch data is deleted. It can be done automatically.

<Modification of First Embodiment of the Invention> (1) In the first embodiment of the invention, the final access position 22, the final prefetch position 23, and the prefetch stop flag 24 of the file are held in the inode. Therefore, even when a plurality of processes are inputting / outputting one file, the pre-reading start / stop control is performed for each file. However, this information is converted to the entry 1 of the file table 182.
It is also possible to hold at 83. At this time, sharing of this entry 183 by different user processes is prohibited. As a result, even when a plurality of user processes perform the same file input / output, it is possible to control the start and stop of prefetch for each user process. It should be noted that these pieces of information can be held in a place other than the file table 182, which can be held separately for each user process.

(2) Instead of the final access position 22 and the final look-ahead position 23, other information may be used. For example, the prefetch start position and the prefetch amount may be used. Further, if the prefetch amount can be specified by another means, only the prefetch start position may be used.

(3) Sequential access determination processing 45 of FIG.
It is also possible in principle to carry out for each user process. When determining whether or not the current access is sequential access for each user process, it is determined whether the current access position of the user process is continuous with respect to the final access position specific to a user process for a certain file. Just make a decision.

(4) This sequential access determination processing 45
It is also possible to use information other than the last access position. For example, as described on page 35 and page 39 of Reference 2, first, the file block number currently being accessed + the current cluster (group of blocks)
Is stored in the inode. At the next access, the file block number being accessed is compared with the stored file block number. If they match, the OS determines that the next access is a sequential access.

(5) The read-ahead logical block number determination process 46 in FIG. 3 may dynamically change the read-ahead logical block number. For example, this process 46 is the read process 6
The following control may be performed each time. That is, in general, the larger the amount of input / output at one time in the magnetic disk storage device 2 or the like, the more efficient the transfer becomes. Therefore, if the sequential access is continuous, the sequential access may continue from the next time onward. Is high. Therefore, the number of prefetch blocks may be controlled so as to increase the number of blocks to be prefetched collectively. In addition, after increasing the number of blocks to be prefetched collectively for a plurality of consecutive accesses as described above,
When a non-sequential request is generated, the number of pre-read blocks can be controlled so as to reduce the number of blocks to be pre-read collectively, which has been increased once, in case a subsequent sequential access occurs again.

<Second Embodiment of the Invention> In the first embodiment of the present invention, it is detected that the prefetched data has been replaced by another data, and the prefetching thereafter is stopped.
This embodiment checks if there is a cache entry that can be used to hold the prefetched data,
If there is no such cache entry, read ahead is stopped. In the present embodiment, replacement of prefetch data with other data does not occur.

The cache management in this embodiment differs from that in the first embodiment in the following points. In the first embodiment of the invention, both the cache entry holding the prefetched logical block data and the cache entry holding the logical block data which is not expected to be used are connected to the AGE free list 320. In the embodiment,
Instead of the AGE free list 320, as shown in FIG. 7, a prefetch free list 910 for registering prefetched logical block data and a no-use-free free list for registering logic block data that is not expected to be used. 920 is used. Reference numerals 91 and 92 are headers of the respective lists. When the logical block data held by the cache entry linked to the prefetch free list 910 is the target of the user read request, the cache entry is removed from the prefetch free list 910 and the data is transferred to the user process. Thereafter, depending on whether the data may be reused, the cache entry is connected to the LRU free list 310 or the no-use free list. The no-usage-free list 92 is transferred to the user process in the read process 6 and concatenates the cache entries holding the data determined not to be reused.

The cache entry used to hold the logical block data including the requested data specified by the read request from the user process 3 is searched from the EMPTY free list 330, and when it is empty, there is no possibility of use. The list 920 is searched. The first cache entry of the LRU free list 310 is used only when any of these is empty. The prefetch free list 910 is not searched for this requested logical block. The search for the cache entry at this time is performed by the same management as when only the used free list 920 is used instead of the AGE free list 320 in the first embodiment of the invention. On the other hand, the cache entry used to hold the prefetched logical block data is similarly searched first from the EMPTY free list 330, and then from the no-usage-free list 920. However, when both free lists 330, 920 are empty, LRU free list 310 is not searched. A cache entry for holding the logical block data to be prefetched is not allocated and prefetching is not performed. In the first embodiment, the search for the cache entry for the prefetch data is executed in step 48, but in the present embodiment, the prefetch stop determination process 4 is performed.
7 is performed as follows.

In the present embodiment, prefetch stop determination processing 4
7 is executed according to FIG. EMPTY Free List 3
It is checked whether 30 is empty (step 101). If this EMPTY free list 330 is not empty, prefetching is performed (step 46 (FIG. 3)). The list 3
When the cache entry in 30 is taken out and the prefetched data is read from the magnetic disk storage device 2, the data is stored in the taken out cache entry. After the prefetched data is transferred to the user process 3, the cache entry is unconditionally connected to the no-use-free list 920. If the list 330 is empty, then it is checked whether the free-for-use free list is empty (step 102). If the free list 920 is not empty, prefetching is performed (step 46 (FIG. 3)) and the cache entry in the free list 920 is used to hold the prefetched data. If this list 920 is empty, it is determined that there is no cache entry that can be reserved for prefetching, and prefetching is not executed. As is apparent from the above, in the present embodiment, in the prefetch stop determination processing 47, it is not necessary to use the final prefetch position 23 and the prefetch flag 24 stored in the inode. However, the final prefetch position 23 is used in step 48 (FIG. 3) to determine the position to start the next prefetch.

There is no guarantee that the prefetch data registered in the prefetch free list 910 will always be used by the user process in the future. Therefore, in the present embodiment, it is conceivable that most of the cache area will be filled with pre-read logical block data that is unlikely to be used in the future. Therefore, in the present embodiment, control such as releasing the cache entry holding the prefetched data that is still registered in the prefetch free list 910 at the time when a predetermined time or more has elapsed after prefetching is separately performed.

In this way, the EMPTY free list 3
30 or prefetching is performed only when there is a cache entry in the free list 920 without possibility of use, and the total amount of prefetched data is limited. On the other hand, the cache entry for holding the requested data designated by the read request issued by the user process is the EMPTY free list 330 or the no-use-free list 92.
Even if it cannot be searched from 0, the cache entry is not searched from the prefetch free list 910. Therefore, unlike the first embodiment, the prefetched data will not be replaced later by the request target data.

Similar to the above-mentioned assumption, the number of cache entries is 1000, the amount of data used by a user process for reading is 8 blocks, the number of user processes is 60, and each user process is mutually It is assumed that read requests for different files are generated and the amount of data to be read ahead is 16 blocks. At this time, in this embodiment, 1000 entries / (8 blocks + 16 blocks) are read by each process.
Up to 41 user processes can be prefetched as in the conventional case. However, for the user processes other than those, prefetching is performed after the cache entries that are no longer expected to be used are registered in the no-use expected free list 920. In this way, 1000 cache entries can be efficiently used so that replacement of prefetched data does not occur. Further, when selecting the cache entry used for holding the prefetched data, it is sufficient to check only the EMPTY free list 330 and the no-use-free list 920. Therefore, the prefetch stop determination processing becomes faster.

<Third Embodiment of the Invention> This embodiment also includes
As in the second embodiment, it is ensured that the prefetched data is not replaced later by the request target data. The second embodiment uses the prefetch free list 910 that registers only the cache entry used for holding the prefetched data, and the cache entry that holds the request target data specified by the read request from the user process is the list 910. This replacement was prevented by searching from lists 310, 330, and 920 other than. But,
In the present embodiment, each cache entry is provided with a flag indicating whether or not the data it holds is prefetched data, and a cache entry holding the requested data specified by the read request from the user process is searched. When this is done, a search is made for a cache entry in which this flag does not indicate that prefetch data is held. Further, in the second embodiment, the cache entry used for holding the prefetched data is specified as the specific free list 3.
It has been limited to the cache entries existing on 30, 920, thereby limiting the number of cache entries used for holding the prefetched data. On the other hand, in the present embodiment, the actual number of cache entries holding prefetched data is set to be equal to or less than a predetermined upper limit value.

In this embodiment, the OS 4 prepares the prefetch cache management table 126 shown in FIG. 9 in advance. This table 1
26 includes an upper limit 121 of the number of prefetch cache entries and a current number 122 of prefetch cache entries. The current read-ahead cache entry number 122 is set to a plurality of values prepared to hold the read-ahead data when a new read request for the read-ahead data is issued to the magnetic disk storage device 2 in step 48 (FIG. 3). The attributes of the cache entry are checked, and the cache entries are counted up by the number of entries that have not been used for holding the prefetch data last time among the plurality of cache entries. Further, when the plurality of cache entries used for holding the prefetch data last time are reused for holding other data this time, the current number 122 of the prefetch cache entries is not used for holding the prefetch data. It is counted down by the number of entries.

Further, in the present embodiment, as shown in FIG. 10, a prefetch flag 88 and a usage schedule flag 89 are further added to each cache entry header 81.
The prefetch flag 88 is set when the cache entry holds the prefetched data, and is reset when the cache entry holds the requested data requested by the user process. The usage schedule flag 89 is set when the cache entry holds prefetch data. After that, a read request for the data is issued from the user process 3, the data is transferred to the user buffer 8, and when it is determined that the data has been used, the usage schedule flag 89 is reset.

In this embodiment, the LRU free list 310 and the AGE free list 3 are the same as in the first embodiment.
20, EMPTY free list 330 used, LRU
The types of cache entries connected to the free list 310 and the AGE free list 320 are also the first embodiment.
Is the same as Similar to the first embodiment, the cache entry registered in the EMPTY free list 330 is searched for the cache entry for storing the requested logical block data specified by the read request issued by the user process 3, and the cache entry is searched. If there are no entries, the AGE free list 320 is searched. However,
This search from the AGE free list 320 differs from the first embodiment in that a cache entry holding data that is unlikely to be used or a cache entry holding used prefetch data is searched.

Here, the data 82A which is not expected to be used
Is data held in the cache entry 81A in which the prefetch flag 88 is reset. The used readahead data 82B is data held in the cache entry 81B in which the readahead flag 88 is set and the usage schedule flag 89 is reset. Therefore, in the search on the AGE free list 320, the data 82C held in the cache entry 81C in which the prefetch flag 88 is set and the usage schedule flag 89 is set is not included in the search target. As a result, the prefetched data that has not been used in the user process is not replaced by the request target data.

On the other hand, unlike the first embodiment, the cache entry for holding the prefetched logical block data is executed as follows in the prefetch stop determination processing 47 and is searched in step 48 (FIG. 3). Not done. FIG.
At 0, first, the AGE free list 320 is searched for a cache entry that holds prefetched and used data. That is, the cache entry in which the prefetch flag 88 is set and the usage schedule flag 89 is reset is searched (step 141).
If there is such a cache entry, then that cache entry is used for prefetching and step 46 (FIG. 3) is performed to perform the prefetching. If there is no such cache entry, the EMPTY free list 33
It is checked if 0 is empty (step 142).

If this list 330 is empty, it is determined whether or not there is a cache entry in the AGE free list 320 that holds logical block data that is unlikely to be used, that is, a cache entry in which the prefetch flag 88 is reset. (Step 144). If there is no such cache entry, prefetch is not executed and step 52 (FIG. 3) is executed.

When it is determined in step 142 that the EMPTY list 330 is not empty, and when it is determined in step 144 that there is a cache entry holding logical block data that is not expected to be used, the current read-ahead cache entry number 122 is set. It is determined whether or not the prefetch cache entry number upper limit 121 has been reached. Current number of read-ahead cache entries 121
However, if the number of prefetch cache entries 122 has been reached, prefetch is not performed and step 53 is executed.
If the current read-ahead cache entry number 121 does not reach the read-ahead cache entry number 122, one cache entry in the EMPTY list 330 searched in step 142 or one cache entry in the AGE free list 320 searched in step 144. Is used for look-ahead data. In order to perform prefetching, step 46 is executed.

The upper limit of the number of read-ahead cache entries may be determined appropriately for each system. For example, to obtain the same effect as the effect shown in the second embodiment,
The upper limit of the number of prefetch cache entries may be set to 520 (1000 entries-8 blocks x 60 files). In this case, prefetching of 32 files (520 entries / 16 blocks) becomes possible.

As described above, also in the present embodiment, the prefetched data is prevented from being replaced by the subsequent request target data, and the total number of cache entries holding the prefetched data is limited to the number set by the OS or less. It Further, in the second embodiment, it is necessary to prepare a specific free list for registering prefetched data, but the present embodiment does not need such a specific free list.

The present invention is not limited to the above-described embodiments of the present invention, and can be realized by the modifications of the first embodiment described above and other modifications. Further, in the above embodiments, the sequential access is a series of accesses for sequentially accessing a plurality of blocks having consecutive addresses. However, the operation of accessing these blocks of consecutive addresses in a fixed number can also be considered as sequential access. Furthermore, more generally, an access operation of sequentially accessing a plurality of logical blocks ordered according to a certain rule can be considered as a sequential access. The present invention can also be applied to these general sequential accesses. Further, in the above embodiment, a plurality of user processes executed in one processor send a file read request to the OS controlling the processor.
It can also be applied to a computer system consisting of multiple processors connected by a network. That is, a user process executed on any one of those processors causes an OS controlling another processor among those processors to cause a file in a magnetic disk storage device connected to the other processor. The same can be applied to the case of sending a read request to the.

[0072]

According to the present invention, it is possible to reduce or eliminate the waste of replacing prefetched data with other data.

[Brief description of drawings]

FIG. 1 is a diagram showing a computer system in which a prefetch control method according to the present invention is executed and a schematic procedure of the method.

FIG. 2 is a diagram showing various tables used by an OS controlling the computer system of FIG.

3 is a flowchart of a read process executed by the computer system of FIG.

4 is a flowchart of a prefetch stop determination process executed in the read process of FIG.

5 is a diagram showing a schematic structure of a cache entry used in the computer system of FIG. 1. FIG.

6 is an explanatory diagram of a structure of a plurality of free lists used in the computer system of FIG.

FIG. 7 is an explanatory diagram of a structure of a plurality of free lists used in the second embodiment of the prefetch control method according to the present invention.

FIG. 8 is a flowchart of a pre-reading stop determination process executed in the second embodiment of the pre-reading control method according to the present invention.

FIG. 9 is a diagram showing a plurality of pieces of information held in a prefetch cache management table executed in the third embodiment of the prefetch control method according to the present invention.

FIG. 10 is a diagram showing a schematic structure of a cache entry used in the third embodiment of the prefetch control method according to the present invention.

FIG. 11 is a flowchart of a prefetch stop determination process executed in the second embodiment of the prefetch control method according to the present invention.

Claims (20)

[Claims] 1. A processor, a main memory, and at least one secondary storage device holding a plurality of files accessible by a plurality of user processes, the main memory comprising:
It has a cache area for temporarily holding data to be transferred between the secondary storage device and the plurality of user processes, and stores data designated by a read request issued by any one of the plurality of user processes. Read from any one of the plurality of files, transfer the read data to the one user process via the cache area, and further, the read request is ordered in the one file. When the request is a read request for sequential access to sequentially access the plurality of data, a computer system that prefetches subsequent data that may be read later by the sequential access from the one file into the cache area, When the read request is a read request for sequential access, Before executing the prefetch, it is determined whether the read request satisfies a predetermined prefetch stop condition, and when the read request satisfies the above condition, the prefetch of the subsequent data is stopped. The above condition has the following conditions when the following data is prefetched:
A read-ahead control method which is a condition for preventing the subsequent data from being replaced with any other data that will be read later from the secondary storage device into the cache area. 2. The computer system is configured to select a data area for storing each of the read subsequent data and the prefetched data according to a predetermined data area selection procedure. The prefetch control method according to claim 1, wherein the condition is determined depending on the data area selection procedure. 3. The condition is a condition for avoiding replacement of the read-ahead subsequent data by any one of the first and second data when the subsequent data is read-ahead. Yes, the first data may be read from the secondary storage device to the cache area in response to a read request that any one of the plurality of user processes will issue after prefetching the subsequent data. The second data may be other subsequent data that may be present, and the second data may be other subsequent data that may be prefetched from the secondary storage device to the cache area in association with the read request. 1. The prefetch control method described in 1. 4. A processor, a main memory, and at least one secondary storage device holding a plurality of files accessible by a plurality of user processes, the main memory comprising:
It has a cache area for temporarily holding data to be transferred between the secondary storage device and the plurality of user processes, and stores data designated by a read request issued by any one of the plurality of user processes. Read from any one of the plurality of files, transfer the read data to the one user process via the cache area, and further, the read request is ordered in the one file. When the request is a read request for sequential access to sequentially access the plurality of data, a computer system that prefetches subsequent data that may be read later by the sequential access from the one file into the cache area, The data read request already issued by any one user process In response, any one of the data already prefetched from the secondary storage device to the cache area is replaced in the cache area by any other data before the data is transferred to the user process. Whether or not one of the plurality of user processes is detected when it is detected that the one data is replaced by any other data before being transferred to the user process. A prefetch control method having a step of stopping the prefetch of data in response to an issued read request for sequential access. 5. The prefetch control method according to claim 4, wherein said detecting step is performed in response to said read request for sequential access issued by any one of said plurality of user processes. 6. The detecting step is performed from a file held in the secondary storage device to which data requested by the read request for sequential access issued by any one of the plurality of user processes belongs. The prefetch control method according to claim 5, wherein the prefetch control method is performed on data that has already been prefetched. 7. The detecting step, wherein the data requested by the read request for sequential access issued by the one user process is data that has been prefetched from the secondary storage device into the cache area. To
The prefetch control method according to claim 5, which is executed for the data. 8. When the prefetch is stopped by the stopping step, a prefetch stop flag set corresponding to the one file is set, and a subsequent read request for sequential access to the one file is issued. When issued from the one user process, it detects whether or not the flag is set. When the flag is set, the detection step for the subsequent read request for sequential access is performed. 6. The prefetch control method according to claim 5, further comprising the step of: stopping the prefetch of the data subsequent to the data requested by the subsequent read request without executing the above. 9. The read step issued by the one user process is:
It is detected whether the read request is for sequential access, and the read request issued by the one user process is
When it is a read request for sequential access, it is detected whether or not the data requested by the read request has been prefetched from the secondary storage device into the cache area, and the data requested by the read request is detected. 6. The prefetch control method according to claim 5, further comprising the step of detecting whether or not the data is present in the cache area when the data is already prefetched from the secondary storage device to the cache area. 10. A processor, a main memory, and at least one secondary storage device holding a plurality of files accessible by a plurality of user processes, wherein the main storage is the secondary storage device and the plurality of the secondary storage devices. Has a cache area for temporarily holding data to be transferred between the user processes, and the data specified by the read request issued by any one of the plurality of user processes is stored in one of the plurality of files. Read from one, transfer the read data to the one user process via the cache area, and further, the read request sequentially accesses a plurality of ordered data in the one file. If the request is a read request for sequential access, it may be read later by the sequential access. In a computer system that pre-reads the data in the cache area from the one file to hold the requested data before reading the data requested by the one read request from the secondary storage device. When the data area other than the data area holding the pre-read unused data is selected as the first data area from the cache area and the one read request is sequential access,
Before performing the pre-reading of the subsequent data, a data area other than the data area holding the pre-read unused data is selected from the cache area as the second data area for holding the subsequent data. Where the prefetched unused data has already been prefetched into the cache area in response to a data read request already issued by one of the user processes,
A prefetch control method that is data that has not been transferred to the user process. 11. The step of selecting the first data area comprises the step of selecting the second data area from the first-type to third-type data areas, wherein the first-type data area is selected. Holds data of a predetermined first type other than pre-read and unused data, and the second-type data area stores data of a predetermined second type other than pre-read and unused data. And the third type data area is a data area that is not used for holding data, and the second method is any of the second type data area and any of the third type data area is the cache area. 11. The prefetch control method according to claim 10, further comprising the step of stopping the prefetch for the subsequent data when not in the range. 12. The data of the first type has already been read from the secondary storage device to the cache area in response to a read request already issued by any of the user processes, and any of the user processes thereafter. Data that is transferred to the user process in response to the issued read request and may be reused by the user process. The above-mentioned second type data has already been issued by one of the user processes. In response to a read request, the data has already been read from the secondary storage device into the cache area, and has already been transferred to that user process in response to a read request issued by one of the user processes. The prefetch control method according to claim 11, wherein the prefetch control method is data that is not likely to be reused. 13. When any of the second type data areas and any of the third type data areas are in the cache area, whether the number of prefetch data areas has reached a predetermined limit value or not. If the number of the prefetch data areas has reached the limit value, the step of stopping the execution of the selecting step of the second data area and stopping the prefetch of the subsequent data is further included. The read-ahead data area is an area for holding data that has been read ahead in the cache area from the secondary storage device in response to a read request issued from any of the user processes. The prefetch control method described. 14. Each pre-read data area holds one of unused pre-read data and used pre-read data, wherein the unused pre-read data is read from one of the user processes. Data that has been prefetched from the secondary storage device to the cache area in response to the request but has not yet been transferred to the user process, and the used prefetched data has already been issued by any of the user processes. 14. The prefetch control method according to claim 13, wherein the prefetch control data is data that has been prefetched from the secondary storage device to the cache area in response to the read request and that has already been transferred to the user process. 15. The first type data is already read from the secondary storage device to the cache area in response to a read request already issued by any user process, and one of the user processes is subsequently read. The second type of data is data that has already been transferred to the user process in response to the issued read request and may be reused by the user process. Read from the secondary storage device to the cache area in response to the read request, and any user process has already transferred to the user process in response to the read request issued by the user process. 14. The prefetch control method according to claim 13, wherein the prefetch control data is data that cannot be reused by the user. 16. The step of selecting the second data area comprises the step of selecting the second data area from a second type data area, a third type and a fourth type data area, and The stopping step is performed when none of the second-type data areas, the third-type data areas, and the fourth-type data areas are in the cache area.
Stopping the read-ahead for the subsequent data, wherein the fourth type of data area is from the secondary storage device in response to a read request already issued by any of the user processes. 12. The prefetch control method according to claim 11, wherein data prefetched in the cache area and already transferred to the user process are held. 17. The data of the first type has already been read from the secondary storage device to the cache area in response to a read request issued by any of the user processes, and any one of the user processes thereafter. The second type of data is data that has already been transferred to the user process in response to the issued read request and may be reused by the user process. Read from the secondary storage device to the cache area in response to the read request, and any user process has already transferred to the user process in response to the read request issued by the user process. 17. The prefetch control method according to claim 16, wherein the prefetch control data is data that cannot be reused by the user. 18. A read-ahead when none of the fourth-type data areas is in the cache area and any of the second-type data areas and any of the third-type data areas are in the cache area. It is detected whether or not the number of data areas has reached a predetermined limit value, and when the number of prefetch data areas has reached the above limit value, execution of the step of selecting the second data area is stopped. The prefetch control method according to claim 16, further comprising the step of stopping the prefetch of the subsequent data. 19. The data of the first type has already been read from the secondary storage device to the cache area in response to a read request issued by any of the user processes, and any one of the user processes thereafter. The second type of data is data that has already been transferred to the user process in response to the issued read request and may be reused by the user process. Read from the secondary storage device to the cache area in response to the read request, and any user process has already transferred to the user process in response to the read request issued by the user process. 19. The prefetch control method according to claim 18, wherein the prefetch control data is data that cannot be reused by the user. 20. A processor, a main memory, and at least one secondary storage device holding a plurality of files accessible by a plurality of user processes, wherein the main storage is the secondary storage device and the plurality of storage devices. Has a cache area for temporarily holding data to be transferred between the user processes, and the data specified by the read request issued by any one of the plurality of user processes is stored in one of the plurality of files. Read from one, transfer the read data to the one user process via the cache area, and further, the read request sequentially accesses a plurality of ordered data in the one file. If the request is a read request for sequential access, it may be read later by the sequential access. In a computer system that pre-reads the data of the one file from the one file to the cache area, it is detected whether the number of pre-read data areas has reached a predetermined limit value, and the number of pre-read data areas is the limit value. The prefetching of the subsequent data is stopped when the prefetching data area is reached in response to a read request already issued from any of the user processes. To a pre-reading control method, which is an area for holding the pre-read data in the cache area.