CN110018793B - Host IO processing control method and device, terminal and readable storage medium - Google Patents
Host IO processing control method and device, terminal and readable storage medium Download PDFInfo
- Publication number
- CN110018793B CN110018793B CN201910290019.7A CN201910290019A CN110018793B CN 110018793 B CN110018793 B CN 110018793B CN 201910290019 A CN201910290019 A CN 201910290019A CN 110018793 B CN110018793 B CN 110018793B
- Authority
- CN
- China
- Prior art keywords
- host
- request
- upper limit
- limit value
- concurrency
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 47
- 238000004064 recycling Methods 0.000 claims description 34
- 238000004590 computer program Methods 0.000 claims description 13
- 239000000725 suspension Substances 0.000 claims description 4
- 238000004886 process control Methods 0.000 claims 1
- 230000008569 process Effects 0.000 abstract description 15
- 230000009286 beneficial effect Effects 0.000 abstract description 2
- 230000000087 stabilizing effect Effects 0.000 abstract description 2
- 238000011084 recovery Methods 0.000 description 7
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- XLYOFNOQVPJJNP-UHFFFAOYSA-N water Substances O XLYOFNOQVPJJNP-UHFFFAOYSA-N 0.000 description 3
- 238000003491 array Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/061—Improving I/O performance
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0638—Organizing or formatting or addressing of data
- G06F3/0644—Management of space entities, e.g. partitions, extents, pools
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
- G06F3/0671—In-line storage system
- G06F3/0683—Plurality of storage devices
- G06F3/0688—Non-volatile semiconductor memory arrays
Abstract
The invention discloses a host IO processing control method, which comprises the following steps: when a host IO request is received, determining an IO concurrency upper limit value corresponding to the current array residual free space information; judging whether the IO request currently processed reaches an IO concurrency upper limit value or not; if so, suspending the host IO request; if not, processing the host IO request; the method limits the current IO quantity of concurrent processing according to the current array residual free space information, namely limits the IO quantity of concurrent processing by setting IO concurrent upper limit values corresponding to various array residual free space information so as to ensure that the array always has a free space and always has certain concurrency to process and respond a host IO request, thereby stabilizing the performance of the array, reducing fluctuation and ensuring that the host service runs smoothly; the invention also discloses a host IO processing control device, a terminal and a computer readable storage medium, which have the beneficial effects.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, a terminal, and a computer-readable storage medium for controlling host IO processing.
Background
At present, a redirection writing mode is often adopted for processing write services in a full flash array, so that garbage collection is needed to recycle a space containing invalid data back, and a space can be provided for new write services. At present, host IO processing is hardly controlled, and host IO is not controlled when an array has free space; only when the array free space is about to be exhausted, all the host IO can be suspended temporarily, and after the garbage is recovered to the space, all the suspended IO are issued and new IO requests are received. It can be seen that the current host IO processing process is easy to generate large fluctuation, which causes large fluctuation of the overall performance of the array, and the host service cannot run smoothly.
Disclosure of Invention
The invention aims to provide a host IO processing control method, a host IO processing control device, a host IO processing control terminal and a computer readable storage medium, which can ensure that an array always has an idle space, certain concurrency can process and respond host IO requests, and ensure the amount of IO requests being processed; therefore, the performance of the array is stabilized, the fluctuation is reduced, and the host service is operated smoothly.
In order to solve the above technical problem, the present invention provides a host IO processing control method, including:
when a host IO request is received, determining an IO concurrency upper limit value corresponding to the current array residual free space information;
judging whether the IO request currently processed reaches the IO concurrence upper limit value or not;
if so, hanging the host IO request;
and if not, processing the host IO request.
Optionally, suspending the host IO request, including:
and putting the host IO request into the tail part of the hanging linked list.
Optionally, the host IO processing control method further includes:
when an IO request is processed, judging whether a suspended host IO request exists or not;
if the suspended host IO request exists, judging whether the IO request currently processed reaches a corresponding IO concurrency upper limit value;
and if the IO concurrency upper limit value does not reach the corresponding IO concurrency upper limit value, taking out the suspended host IO requests one by one for processing until the corresponding IO concurrency upper limit value is reached.
Optionally, the host IO processing control method further includes:
when a garbage recycling starting instruction is received, determining corresponding garbage recycling strength according to the current array residual free space information;
and executing garbage recycling operation according to the garbage recycling strength.
The present invention also provides a host IO processing control apparatus, including:
the IO request upper limit determining module is used for determining an IO concurrency upper limit value corresponding to the current array residual free space information when a host IO request is received;
the first judgment module is used for judging whether the IO request currently processed reaches the IO concurrency upper limit value or not;
the hanging module is used for hanging the host IO request if the IO concurrency upper limit value is reached;
and the IO processing module is used for processing the host IO request if the IO concurrency upper limit value is not reached.
Optionally, the suspension module is specifically a module that puts the host IO request into the tail of the suspension linked list.
Optionally, the host IO processing control apparatus further includes:
the second judgment module is used for judging whether a suspended host IO request exists or not when an IO request is processed;
the third judgment module is used for judging whether the IO request currently processed reaches the corresponding IO concurrency upper limit value if the suspended host IO request exists;
and the suspended IO processing module is used for taking out the suspended host IO requests one by one to process until the corresponding IO concurrency upper limit value is reached if the corresponding IO concurrency upper limit value is not reached.
Optionally, the host IO processing control apparatus further includes:
the garbage recycling upper limit determining module is used for determining corresponding garbage recycling strength according to the current array residual free space information when receiving a garbage recycling starting instruction;
and the garbage recycling module is used for executing garbage recycling operation according to the garbage recycling strength.
The present invention also provides a terminal, comprising:
a memory for storing a computer program;
and the processor is used for realizing the steps of the host IO processing control method when the computer program is executed.
The present invention further provides a computer-readable storage medium, in which a computer program is stored, and when the computer program is executed by a processor, the steps of the host IO processing control method are implemented.
The invention provides a host IO processing control method, which comprises the following steps: when a host IO request is received, determining an IO concurrency upper limit value corresponding to the current array residual free space information; judging whether the IO request currently processed reaches an IO concurrency upper limit value or not; if so, hanging the host IO request; and if not, processing the host IO request.
Therefore, the method limits the current number of the IO concurrent processing according to the remaining free space information of the current array, namely, limits the number of the IO concurrent processing by setting IO concurrent upper limit values corresponding to the remaining free space information of various arrays so as to ensure that the arrays always have free space, always have certain concurrence to process and respond to IO requests of a host computer and ensure the amount of the IO requests being processed; thereby stabilizing the performance of the array, reducing the fluctuation and ensuring the smooth operation of the host business; the invention also provides a host IO processing control device, a terminal and a computer readable storage medium, which have the beneficial effects and are not described herein again.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the provided drawings without creative efforts.
Fig. 1 is a flowchart of a host IO processing control method according to an embodiment of the present invention;
fig. 2 is a block diagram of a host IO processing control apparatus according to an embodiment of the present invention.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, but not all embodiments of the present invention. All other embodiments, which can be obtained by a person skilled in the art without making any creative effort based on the embodiments in the present invention, belong to the protection scope of the present invention.
At present, the host IO processing is hardly controlled, and the host IO is not controlled at all when the array has free space; only when the array free space is about to be exhausted, all the host IO is suspended temporarily, and after the garbage is recovered to the space, all the suspended IO is issued and a new IO request is received. It can be seen that the current host IO processing is prone to large fluctuations. Specifically, when the array has space, the IO amount of the host is not controlled, the performance of the array is good, and when the array space is insufficient, all the IO in the host is suspended by the array, so that the performance of the array is very poor; after waiting for the space received by garbage recovery, unrestricted host IO is issued to the array in bulk, which has better performance, but quickly consumes the recovered space, so that all IOs must be suspended again, the overall performance of the array fluctuates greatly, and the host service cannot run smoothly. In this embodiment, the problem is overcome by limiting the host IO concurrency amount. Referring to fig. 1 in detail, fig. 1 is a flowchart of a host IO processing control method according to an embodiment of the present invention; the method can comprise the following steps:
s101: and when a host IO request is received, determining an IO concurrency upper limit value corresponding to the current array residual free space information.
In this embodiment, the information of the remaining free space of the array is not specifically limited, and the information of the remaining free space of the array can be directly used as the information of the remaining free space of the array according to the ratio of the remaining free space of the array to the total space of the array, that is, the ratio of the remaining free space of the array; of course, the remaining free space amount of the array can also be directly used as the remaining free space information of the array.
In order to realize the control of the host IO processing in this embodiment, the situation that the array has almost no free space is prevented. The array is ensured to have free space all the time, certain concurrency can process and respond the host IO request, and the amount of the IO request being processed is ensured; therefore, the performance of the array is stabilized, the fluctuation is reduced, and the host service is operated smoothly.
In this embodiment, an IO concurrency upper limit corresponding to the remaining free space information of each array is set. It should be noted that, in this embodiment, a specific numerical value of the IO concurrency upper limit value corresponding to the remaining free space information of each array is not limited, and a numerical value of the remaining free space information of each array and the number of the remaining free space information of each array are also not limited. That is, in the present embodiment, the host IO amount processed simultaneously can be divided into a plurality of levels according to the array remaining free space information. The IO concurrency processed by each level is different, and the IO concurrency processed by each level corresponds to different levels when the proportion of the remaining free space of the array reaches different water levels. At this time, the water level can be understood as the degree of the remaining free space of the current array occupying the whole space. For example, the upper limit of the IO amount handled by the method is divided into 10 levels: 5000. 3600, 2800, 2100, 1500, 1000, 600, 300, 100, 40, the remaining free space proportion of the respective corresponding array may be: 12%, 10.8%, 9.6%, 8.4%, 7.2%, 6%, 4.8%, 3.6%, 2.4%, 0.6%. At this time, it can be understood that when the remaining free space ratio of the current array is 12%, the corresponding IO concurrency upper limit value is 5000, and of course, a user may automatically calculate the IO concurrency amount upper limit of each level and the corresponding remaining free space ratio of the array according to the configuration and the capability of the array. Of course, the grade at this time can be understood as: and setting a corresponding IO concurrency upper limit value for the proportion range of the remaining free space of each array. In this embodiment, the remaining free space ratio range of each array is not limited, and a specific numerical value of the IO concurrence upper limit value corresponding to the remaining free space ratio range of each array is not limited. For example, when the remaining free space ratio of the array is (12%, 10.8%), the corresponding IO concurrency upper limit value is 5000, when the remaining free space ratio of the array is (10.8%, 9.6%), the corresponding IO concurrency upper limit value is 3600, and when the remaining free space ratio of the array is greater than 12%, the corresponding IO concurrency upper limit value may not be set.
When a host IO request is received, the present embodiment first determines a current corresponding IO concurrency upper limit value, and then determines whether the current host IO request can be executed immediately according to the number of IO requests actually being processed currently.
S102: judging whether the IO request currently processed reaches an IO concurrency upper limit value or not; if yes, entering S103; if not, the process proceeds to S104.
S103: the host IO request is pending.
S104: host IO requests are processed.
Specifically, in this embodiment, it is necessary to record the number of IO requests currently being processed. If the IO request currently being processed reaches the IO concurrency upper limit value, which indicates that the received host IO request cannot be processed immediately at this time, the host IO request needs to be suspended first, and the host IO request is processed when the host IO request can be executed. If the IO request currently being processed does not reach the IO concurrency upper limit, it is indicated that the received host IO request can be processed immediately at this time, that is, the remaining IO processing capability still exists currently.
In this embodiment, the mode of recording the number of IO requests currently being processed is not limited, and may be implemented by a counter, for example. Specifically, a counter is used to record the number of host IO requests being processed by the array. The counter is incremented when the array begins processing a host IO request and decremented when the IO request is completed.
In this embodiment, a manner of suspending the host IO request is also not limited, and for example, an IO request that cannot be processed in time may be stored in a linked list. Further, in order to avoid that the host IO request is in a suspended state for a long time and cannot be processed in time, in this embodiment, the suspended host IO request may be set to a first-in first-out mode, that is, the host IO request put in first is taken out first to be processed when the processing is allowed. This function may be implemented, for example, by a linked list. Specifically, the host IO request is placed at the tail of the suspension linked list. Correspondingly, in this embodiment, when a host IO request is sent to the array, the IO concurrency upper limit value for processing IO corresponding to the current array is checked, and if the number of IO requests currently being processed reaches the IO concurrency upper limit value, the received host IO request is suspended, for example, the host IO request is suspended to the tail of a linked list; and if the number of the IO requests currently processed does not reach the IO concurrency upper limit value, immediately starting to process the IO requests.
In this embodiment, when an IO request is completed, the suspended IO request needs to be processed. Therefore, the host IO request can be guaranteed to be processed in time, the performance of the array is stabilized, the fluctuation is reduced, and the host business can run smoothly. Preferably, this embodiment may further include:
when an IO request is processed, judging whether a suspended host IO request exists or not;
if the suspended host IO request exists, judging whether the IO request currently processed reaches a corresponding IO concurrency upper limit value;
and if the corresponding IO concurrency upper limit value is not reached, taking out the suspended host IO requests one by one for processing until the corresponding IO concurrency upper limit value is reached.
The above process may specifically be: when the array processing completes a host IO request, checking whether a suspended IO request exists, if so, taking out the suspended IO requests one by one to start processing until the number of the IO requests currently processed by the array does not reach the corresponding IO concurrency upper limit value, and then not taking out the suspended IO request.
Specifically, in this embodiment, when processing an IO request is completed, it may be determined whether there is a suspended host IO request, and if there is no suspended host IO request, the processing may not be performed, or the receiving host may be in a state of waiting for issuing the IO request processing again. This embodiment does not limit this. If the pending host IO request exists, it is indicated that the pending IO request which needs to be processed exists, but before the IO requests are processed, it is also necessary to determine whether the IO request currently being processed reaches the corresponding IO concurrency upper limit value. If the IO concurrency upper limit value corresponding to the currently processed IO request is reached, the temporarily unset free space can be used for processing the IO request, and the suspended IO is not processed at the moment. And if the IO concurrency upper limit value corresponding to the IO request currently being processed is not reached, taking out the suspended host IO requests one by one for processing until the corresponding IO concurrency upper limit value is reached. That is, at this time, the difference between the IO concurrency upper limit corresponding to the distance between the IO request currently processed and the IO concurrency upper limit, that is, how many host IO requests can be currently processed, may be calculated first, and then the corresponding number of suspended IO requests may be taken out for processing according to the first-in first-out sequence. If the current IO concurrency upper limit is not reached, only one IO request may be taken out for processing each time, and after the processing is completed, the next IO request may be taken out for processing, and the processing may be sequentially performed. That is to say, the number of suspended IOs that must be taken out at one time according to the difference between the IO concurrency upper limit and the IO request distance currently processed is not limited in this embodiment.
Based on the above technical solution, the method for controlling host IO processing according to the embodiment of the present invention limits the current number of concurrent processing IO according to the current array remaining free space information, that is, limits the number of concurrent processing IO by setting IO concurrent upper limit values corresponding to various array remaining free space information, so as to ensure that an array always has a free space, always has a certain amount of concurrency to process and respond to a host IO request, and ensures the amount of IO requests being processed; therefore, the performance of the array is stabilized, the fluctuation is reduced, and the host business is smoothly operated.
Currently, data relocation and metadata modification are generated during garbage collection, so that certain processes and time are required to recycle the available space of the array through garbage, while host IO always consumes the available space of the array. Therefore, if the control is not good between the garbage collection space and the host IO consumption space, the performance and stability of the host service can be affected. At present, the intensity of garbage recovery is hardly controlled. Therefore, if the currently set garbage recycling strength is too high, the performance of the array is unstable, the fluctuation is large, and the host service cannot run smoothly; if the currently set garbage recycling strength is too small, the balance of the remaining free space of the array is low, so that the number of concurrent IO processing is small, and the IO request processing efficiency is influenced. In order to further improve the host IO processing control efficiency, the present embodiment is further added with the control on the garbage recycling strength, so as to ensure the stable performance of the array, reduce the fluctuation, and enable the host business to run smoothly. Preferably, this embodiment may further include:
when a garbage recycling starting instruction is received, determining corresponding garbage recycling strength according to the information of the remaining free space of the current array;
and executing garbage recycling operation according to the garbage recycling strength.
It should be noted that, in this embodiment, the specific correspondence between the array remaining free space information and the garbage collection intensity is not limited. The set quantity of the garbage recycling strength is not limited, and certainly, the value of each garbage recycling strength is not limited. That is, in this embodiment, the intensity of garbage collection is also divided into a plurality of levels, and the GRAIN corresponding to the collection intensity of each level is different concurrently, where the GRAIN is the minimum unit for space allocation and collection on the array. And respectively corresponding to different levels when the rest free space of the array reaches different water levels. In this embodiment, the number of levels of the garbage collection intensity and the number of control levels for the host IO volume may be different. For example, the level of the IO concurrency amount processed in the above embodiment is divided into 10 levels, while the level of the garbage collection strength may be divided into 3 levels in the present embodiment. For example, the recovery GRAIN concurrency granularity of each grade can be respectively as follows: 256 × 4, 256 × 6, 256 × 10, the remaining free space ratio of the corresponding array may be: 12%, 8.4% and 3.6%. Also, in this embodiment, the respective levels of GRAIN concurrency granularity and the corresponding proportion of the remaining free space of the array can be automatically calculated according to the configuration and the capability of the array. Of course, the grade at this time can be understood as: and setting a corresponding recycling GRAIN concurrency granularity, namely garbage recycling strength, for each array residual free space proportion range. In this embodiment, the range of the proportion of the remaining free space of each array is not limited, and a specific value of the concurrent granularity of the recycle gain corresponding to the range of the proportion of the remaining free space of each array is not limited. For example, when the remaining proportion of free space of the array is at (12%, 8.4% >), the corresponding GRAIN concurrency granularity may be 256 x 4, and when the remaining proportion of free space of the array is at (8.4%, 3.6% >), the corresponding GRAIN concurrency granularity may be 256 x 6.
The specific process of executing the garbage collection operation according to the set garbage collection intensity in this embodiment may be: and when the garbage collection is started or the GRAIN recovery task is completed every time and other occasions for issuing new GRAIN recovery tasks are given, checking the currently set upper limit of the concurrent GRAIN recovery number, issuing the recovery tasks of the number according to the number of the distance upper limit, and executing corresponding garbage collection operation.
Based on the technical scheme, the embodiment of the invention provides a method for optimizing host IO performance during garbage collection of an array facing a full flash memory array, according to the remaining free space amount of the array, the concurrency amount of host IO requests processed by the array and the garbage collection strength are controlled in a grading mode, the remaining host IO requests exceeding the concurrency amount are temporarily suspended, when the IO requests processed by the array are processed, the suspended host IO requests are continuously processed, the array is always ensured to process and respond the host IO requests, and the amount of the IO requests processed is ensured. Therefore, the performance of the array is stabilized, the fluctuation is reduced, and the host business is smoothly operated.
The following describes a host IO processing control apparatus, a terminal, and a computer-readable storage medium according to embodiments of the present invention, and the host IO processing control apparatus, the terminal, and the computer-readable storage medium described below may be referred to in correspondence with the host IO processing control method described above.
Referring to fig. 2, fig. 2 is a block diagram of a host IO processing control apparatus according to an embodiment of the present invention; the apparatus may include:
an IO request upper limit determining module 100, configured to determine, when a host IO request is received, an IO concurrency upper limit corresponding to remaining free space information of a current array;
a first determining module 200, configured to determine whether an IO request currently being processed reaches an IO concurrency upper limit value;
the hanging module 300 is used for hanging the host IO request if the IO concurrency upper limit value is reached;
the IO processing module 400 is configured to process the host IO request if the IO concurrency upper limit value is not reached.
Based on the above embodiment, the hanging module 300 is specifically a module for placing the host IO request into the tail of the hanging chain table.
Based on any of the above embodiments, the apparatus may further include:
the second judgment module is used for judging whether a suspended host IO request exists or not when an IO request is processed;
the third judgment module is used for judging whether the IO request currently processed reaches the corresponding IO concurrency upper limit value or not if the suspended host IO request exists;
and the suspended IO processing module is used for taking out the suspended host IO requests one by one to process until the corresponding IO concurrency upper limit value is reached if the corresponding IO concurrency upper limit value is not reached.
Based on any of the above embodiments, the apparatus may further include:
the garbage recycling upper limit determining module is used for determining corresponding garbage recycling strength according to the current array residual free space information when receiving a garbage recycling starting instruction;
and the garbage recycling module is used for executing garbage recycling operation according to the garbage recycling strength.
It should be noted that, based on any of the above embodiments, the device may be implemented based on a programmable logic device, where the programmable logic device includes an FPGA, a CPLD, a single chip, a processor, and the like. The programmable logic device may be in a terminal (e.g., a memory system).
Based on the above technical solution, the host IO processing control apparatus provided in the embodiment of the present invention hierarchically controls the concurrency amount of the host IO requests being processed by the array and the garbage collection strength according to the remaining free space amount of the array, and temporarily suspends the remaining host IO requests exceeding the concurrency amount, so as to ensure that the speed of the garbage collection space can meet the speed of space consumption by the host IO requests.
An embodiment of the present invention further provides a terminal, including: a memory for storing a computer program; and the processor is used for realizing the steps of the host IO processing control method in any embodiment when executing the computer program. If the processor is used for executing a computer program, determining an IO concurrency upper limit value corresponding to the current array residual free space information when a host IO request is received; judging whether the IO request currently processed reaches an IO concurrency upper limit value or not; if so, hanging the host IO request; and if not, processing the host IO request.
The terminal is not limited in this embodiment, and may be a storage system, for example.
The present invention further provides a computer-readable storage medium, where a computer program is stored, and when being executed by a processor, the computer program implements the steps of the host IO processing control method according to any of the above embodiments. When a computer program is executed by a processor, determining an IO concurrency upper limit value corresponding to the current array residual free space information when a host IO request is received; judging whether the IO request currently processed reaches an IO concurrency upper limit value or not; if so, hanging the host IO request; and if not, processing the host IO request.
The computer-readable storage medium may include: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.
The embodiments are described in a progressive manner in the specification, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other. The device, the terminal and the computer-readable storage medium disclosed by the embodiment correspond to the method disclosed by the embodiment, so that the description is relatively simple, and the relevant points can be referred to the description of the method part.
Those of skill would further appreciate that the various illustrative components and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the components and steps of the various examples have been described above generally in terms of their functionality in order to clearly illustrate this interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the technical solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
The detailed description of the host IO processing control method, the host IO processing control device, the host IO processing control terminal, and the computer readable storage medium provided by the present invention are provided above. The principles and embodiments of the present invention have been described herein using specific examples, which are presented only to assist in understanding the method and its core concepts of the present invention. It should be noted that, for those skilled in the art, it is possible to make various improvements and modifications to the present invention without departing from the principle of the present invention, and those improvements and modifications also fall within the scope of the claims of the present invention.
Claims (6)
1. A host IO processing control method is characterized by comprising the following steps:
when a host IO request is received, determining an IO concurrency upper limit value corresponding to the current array residual free space information;
judging whether the IO request currently processed reaches the IO concurrence upper limit value or not;
if so, hanging the host IO request;
if not, processing the host IO request;
the host IO processing control method further includes:
when an IO request is processed, judging whether a suspended host IO request exists or not;
if the suspended host IO request exists, judging whether the IO request currently processed reaches a corresponding IO concurrency upper limit value;
if the corresponding IO concurrency upper limit value is not reached, the suspended host IO requests are taken out one by one to be processed until the corresponding IO concurrency upper limit value is reached;
the host IO processing control method further comprises the following steps:
when a garbage recycling starting instruction is received, determining corresponding garbage recycling strength according to the information of the remaining free space of the current array;
and executing garbage recycling operation according to the garbage recycling strength.
2. The host IO processing control method according to claim 1, wherein suspending the host IO request includes:
and putting the host IO request into the tail part of the hanging linked list.
3. A host IO process control apparatus, comprising:
the IO request upper limit determining module is used for determining an IO concurrency upper limit value corresponding to the current array residual free space information when a host IO request is received;
the first judgment module is used for judging whether the IO request currently processed reaches the IO concurrency upper limit value or not;
the suspension module is used for suspending the host IO request if the IO concurrency upper limit value is reached;
the IO processing module is used for processing the host IO request if the IO concurrency upper limit value is not reached;
wherein, host computer IO handles controlling means still includes:
the second judgment module is used for judging whether a suspended host IO request exists or not when an IO request is processed;
the third judgment module is used for judging whether the IO request currently processed reaches the corresponding IO concurrency upper limit value or not if the suspended host IO request exists;
the suspended IO processing module is used for taking out the suspended host IO requests one by one for processing until the corresponding IO concurrency upper limit value is reached if the corresponding IO concurrency upper limit value is not reached;
the host IO processing control apparatus further includes:
the garbage collection upper limit determining module is used for determining corresponding garbage collection intensity according to the current array residual free space information when a garbage collection starting instruction is received;
and the garbage recycling module is used for executing garbage recycling operation according to the garbage recycling strength.
4. The host IO processing control device according to claim 3, wherein the suspend module is specifically a module that puts the host IO request into a tail of a suspend chain table.
5. A terminal, comprising:
a memory for storing a computer program;
a processor for implementing the steps of the host IO processing control method according to claim 1 or 2 when executing the computer program.
6. A computer-readable storage medium, having stored thereon a computer program which, when executed by a processor, implements the steps of the host IO processing control method of claim 1 or 2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910290019.7A CN110018793B (en) | 2019-04-11 | 2019-04-11 | Host IO processing control method and device, terminal and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910290019.7A CN110018793B (en) | 2019-04-11 | 2019-04-11 | Host IO processing control method and device, terminal and readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110018793A CN110018793A (en) | 2019-07-16 |
| CN110018793B true CN110018793B (en) | 2022-07-22 |
Family
ID=67191070
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910290019.7A Active CN110018793B (en) | 2019-04-11 | 2019-04-11 | Host IO processing control method and device, terminal and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110018793B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112948208B (en) * | 2021-02-24 | 2022-06-21 | 视若飞信息科技(上海)有限公司 | Memory monitoring and recycling method, system, equipment and storage medium |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103530237A (en) * | 2013-10-31 | 2014-01-22 | 厦门大学 | Solid-state disc array garbage collecting method |
| CN109561133A (en) * | 2018-10-23 | 2019-04-02 | 深圳壹账通智能科技有限公司 | Method for processing business, device, equipment and computer readable storage medium |
-
2019
- 2019-04-11 CN CN201910290019.7A patent/CN110018793B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103530237A (en) * | 2013-10-31 | 2014-01-22 | 厦门大学 | Solid-state disc array garbage collecting method |
| CN109561133A (en) * | 2018-10-23 | 2019-04-02 | 深圳壹账通智能科技有限公司 | Method for processing business, device, equipment and computer readable storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110018793A (en) | 2019-07-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9952903B2 (en) | Background task resource control | |
| CN106874031B (en) | Method and device for starting system program of terminal equipment | |
| CN109960589B (en) | Method and device for realizing system software layer of embedded system and readable medium | |
| WO2016115000A1 (en) | Hybrid scheduler and power manager | |
| CN109614377A (en) | File delet method, device, equipment and the storage medium of distributed file system | |
| US20160147572A1 (en) | Modifying memory space allocation for inactive tasks | |
| CN104932933A (en) | Spin lock acquisition method and apparatus | |
| CN110018793B (en) | Host IO processing control method and device, terminal and readable storage medium | |
| US8966212B2 (en) | Memory management method, computer system and computer readable medium | |
| CN111625546A (en) | Data writing method, device, equipment and medium | |
| CN108536609B (en) | Memory fragment management system and method | |
| US20160266808A1 (en) | Information processing device, information processing method, and recording medium | |
| CN116301644B (en) | Data storage method, system, terminal and medium based on multi-hard disk coordination | |
| CN102843369B (en) | The Network Access Method at UI interface and system | |
| CN115756866A (en) | Load balancing method, device and storage medium | |
| CN107018163B (en) | Resource allocation method and device | |
| CN104182264A (en) | eMMC (embedded multi-media card) starting optimization method and device thereof | |
| CN113126924B (en) | Data migration method, device and equipment and computer readable storage medium | |
| CN111176848B (en) | Cluster task processing method, device, equipment and storage medium | |
| CN114153592A (en) | Physical host load scheduling method and device of cloud platform, electronic equipment and medium | |
| CN108563507A (en) | A kind of EMS memory management process, device, equipment and readable storage medium storing program for executing | |
| EP2687944A2 (en) | Apparatus and method for managing power based on data | |
| CN111090627B (en) | Log storage method and device based on pooling, computer equipment and storage medium | |
| JP2024506419A (en) | Recommended methods for operating and stopping work platforms, equipment, electronic equipment, and warehouse systems | |
| JP2008225641A (en) | Computer system, interrupt control method and program |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |