CLIAMS:WE CLAIM

1. A method of processing storage commands, comprising:
receiving a storage command from a host device by a storage device, wherein the storage command comprises rate information indicating rate of repetition of the command;
processing the storage command at a pre-determined time interval repeatedly based on the rate information; and
sending a response message to the host device each time the storage command is repeatedly processed.

2. The method of claim 1, further comprising:
updating logical block address each time the storage command is processed

3. The method of claim 1, further comprising:
terminating the repeated processing of the storage command upon processing the storage command for a pre-determined number of times, wherein the storage command indicates the pre-determined number of times for which the storage command is to be repeatedly processed.

4. The method of claim 1, further comprising:
terminating the repeated processing of the storage command upon receiving a request for terminating repetition of the storage command from the host device.

5. The method of claim 1, further comprising:
postponing the storage commands for a pre-determined time duration, wherein the storage commands indicates the pre-determined time duration.

6. The method of claim 1, further comprising:
determining whether a data-out packet is received from the host device prior to expiry of a preset time period;
terminating processing of the storage command if the data-out packet is not received prior to expiry of the preset time period; and
transitioning to a new state upon terminating processing of the storage command.

7. The method of claim 1, further comprising:
determining time required to process the storage command; and
sending a response message indicating time required to process the storage command to the host device.

8. An apparatus comprising:
a processor; and
a memory coupled to the processor, wherein the memory comprises a command processing module configured for:
receiving a storage command from a host device, wherein the storage command comprises rate information indicating rate of repetition of the command;
repeatedly processing the storage command at a pre-determined time interval based on the rate information; and
sending a response message to the host device upon processing of the storage command each time.

9. The apparatus of claim 8, wherein the command processing module is configured for updating logical block address upon processing the storage command each time.

10. The apparatus of claim 8, wherein the command processing module is configured for terminating the repeated processing of the storage command upon processing the storage command for a pre-determined number of times, wherein the storage command indicates the pre-determined number of times for which the storage command is to be repeatedly processed.

11. The apparatus of claim 8, wherein the command processing module is configured for terminating the repeated processing of the storage command upon receiving a request for terminating repetition of the storage command from the host device.

12. The apparatus of claim 8, wherein the command processing module is configured for postponing the storage commands for a pre-determined time duration, wherein the storage commands indicates the pre-determined time duration.

13. The apparatus of claim 8, wherein the command processing module is configured for:
determining whether a data-out packet is received from the host device prior to expiry of a preset time period;
terminating processing of the storage command if the data-out packet is not received prior to expiry of the preset time period; and
transitioning to a new state upon terminating processing of the storage command.

14. The apparatus of claim 8, wherein the command processing module is configured for:
determining time required to process the storage command; and
sending a response message indicating time required to process the storage command to the host device.

15. A system comprising:
a host device for generating a command comprising a rate information indicating rate of repetition of the storage command; and
a storage device coupled to the host device and configured for:
repeatedly processing the storage command at a pre-determined time interval based on the rate information; and
sending a response message to the host device upon processing of the storage command each time.

16. The system of claim 15, wherein the storage device is configured for terminating the repeated processing of the storage command upon processing the storage command for a pre-determined number of times, wherein the storage command indicates the pre-determined number of times for which the storage command is to be repeatedly processed.

17. The system of claim 15, wherein the host device is configured for sending a request message to stop repeated processing of the storage command.

18. The system of claim 17, wherein the storage device is configured for terminating the repeated processing of the storage command based on the request message.

19. The system of claim 15, wherein the storage device is configured for postponing the storage commands for a pre-determined time duration, wherein the storage commands indicates the pre-determined time duration.

20. The system of claim 15, wherein the storage device is configured for:
determining whether a data-out packet is received from the host device prior to expiry of a preset time period;
terminating processing of the storage command if the data-out packet is not received prior to expiry of the preset time period; and
transitioning to a new state upon terminating processing of the storage command.

21. The system of claim 15, wherein the storage device is configured for:
determining time required to process the storage command; and
sending a response message indicating time required to process the storage command to the host device.
,TagSPECI:FIELD OF THE INVENTION

The present invention generally relates to the field of storage devices, and more particularly relates to efficiently processing of storage commands.

BACKGROUND OF THE INVENTION

Most of transactions between a host device and a storage device encountered are deterministic in nature. For example, media player reads data from a memory card at a constant rate, network upload or download occur at a constant rate depending on the network and interface capabilities and file copy happens at a constant rate based on the involved Interface/Host/Device capabilities. The percentage of occurrence of deterministic scenarios (transactions) overwhelmingly exceeds the occurrence of non-deterministic scenarios (transactions).

There are few problems in existing systems facilitating exchange of commands (or packets) between the host device and the storage device. Firstly, as the host device sends commands based on application data rate, amount of data read from the storage device generally depends on how much data an application can buffer for processing. As the buffers are limited, there may be an occasion wherein the host device sends many read commands and gets data in chunks, intervals depending on application data consumption rate, whenever required. Hence, a lot of commands need to be sent by the host device, thus creating lot of interrupts to the storage device. Secondly, the host device has to spend a lot of time and resources for preparation/processing of the storage command since the host device has to send same commands. Thirdly, there is no possibility of executing a particular command or a sequence of commands for a given number of times after every predefined interval of time. In order to achieve the above mentioned feature, the host device has to send the same commands again and again whenever needed. Finally, only synchronization mechanism between the host device and the storage device is buffering and interrupts. The host device cannot decide when a command needs to be executed. Additionally, the host device does not know when a particular command would be addressed or completed, thereby making deterministic scenarios also non-deterministic.

BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWINGS

Figure 1 is a block diagram of a storage system capable of efficiently processing storage commands, according to one embodiment.

Figure 2 is a flow diagram illustrating an exemplary method of repeatedly processing storage commands, according to one embodiment.

Figure 3 is a flow diagram illustrating an exemplary method of repeatedly processing storage commands, according to another embodiment.

Figure 4 is a schematic representation illustrating format of a Universal Flash Storage Protocol Information Unit (UPIU) header, according to one embodiment.

Figure 5 is flow diagram illustrating an exemplary method of processing of storage commands, according to yet another embodiment.

Figure 6 is a flow diagram illustrating an exemplary method of processing storage commands, according to further another embodiment.

Figure 7 is a flow diagram illustrating an exemplary method of processing storage commands, according to yet a further embodiment.

Figure 8 is a flow diagram illustrating an exemplary method of processing storage commands, according to still embodiment.

Figure 9 is a schematic representation illustrating format of a UPIU header including a request for time required to process an UPIU, according to one embodiment.

Figure 10 is a schematic representation illustrating format of a time info UPIU packet indicating time required to process the UPIU, according to one embodiment.

Figure 11 is a schematic representation illustrating format of a response message indicating time required to process the UPIU, according to another embodiment.

The drawings described herein are for illustration purposes only and are not intended to limit the scope of the present disclosure in any way.

DETAILED DESCRIPTION OF THE INVENTION

The present invention provides a method and system for efficiently processing storage commands. In the following detailed description of the embodiments of the invention, reference is made to the accompanying drawings that form a part hereof, and in which are shown by way of illustration specific embodiments in which the invention may be practiced. These embodiments are described in sufficient detail to enable those skilled in the art to practice the invention, and it is to be understood that other embodiments may be utilized and that changes may be made without departing from the scope of the present invention. The following detailed description is, therefore, not to be taken in a limiting sense, and the scope of the present invention is defined only by the appended claims.

The terms ‘storage command’, ‘command’ are interchangeably used throughout the document.

Figure 1 is a block diagram of a storage system 100 capable of efficiently processing storage commands, according to one embodiment. In Figure 1, the system 100 includes a host device 102 and a storage device 104. The host device 102 may be personal computer, smart phone, mobile phone, digital camera, video recorder, tablet computer, personal digital assistant and the like. The storage device 104 is Universal Flash Storage (UFS), Solid State Drive (SSD) cards, memory cards and Universal Serial Bus (USB) flash drives, and so on. The host device 102 includes a processor 106, a memory unit 108 and a host interface 114. The memory unit 108 includes a plurality of applications 110 (e.g., media player application, word processing application, etc.) and a command generation module 112. The storage device 104 includes a storage interface 116, a controller 118 containing a command processing module 120, and a physical memory 122.

In one embodiment, the command generation module 112 generates a read/write command (commonly referred to as storage command) for reading/writing data from/into the storage device 104. The command generation module 112 may indicate a rate of repetition and number of commands to be repeatedly processed in the generated read/write command. The command generation module 112 sends the generated read/write command to the storage device 104 via the host interface 114. The command processing module 120 automatically processes the command after a preset time interval for the number of times indicated in the command received from the host device 102. The command processing module 120 sends a response to the host device 102 via the storage interface 116 after processing the command each time. In case, when the host device does not specify the number of times the command is to be repeatedly processed in the command, the host device 102 sends a request to stop repeated processing of the commands when desired action (read/write) is complete. Until then the command processing module 120 repeatedly processes the command after the preset time interval.

In another embodiment, the command generation module 112 generates a write command with a preset time period and sends the write command to the storage device 104 via the host interface 114. The command processing module 120 processes the write command and sends a RTT to the host device 102. The command processing module 120 determines whether data-out packet is received from the host device 102 within the preset time period indicated in the write command. If the data-out packet is not received within the preset time period, the command processing module 120 terminates the write operation and enters an idle mode. Alternatively, the command processing module 120 may process a new write command upon termination of the write operation.

In yet another embodiment, the command generation module 112 generates read commands indicating associated time information and sends the read commands to the storage device 104 via the host interface 114. The command processing module 120 postpones processing of the read commands based on the associated time information. The command processing module 120 processes each of the read command at a scheduled time and sends response to the host device 102 via the storage interface 116.

In further embodiment, the command generation module 112 generates a command with a request for processing time and sends the command to the storage device 104. The command processing module 120 determines the time required to process the command based on the request and sends a response message indicating the time required to process the command to the host device 102 via the storage interface 116. The command generation module 112 determines whether the command has to be processed earlier than the time indicated in the response message and modifies the priority associated with the command based on the determination. Accordingly, the command generation module 112 sends the modified priority of the command to the storage device 104. Accordingly, the command processing module 120 processes the command according to the modified priority.

Figure 2 is a flow diagram 200 illustrating an exemplary method of repeatedly processing storage commands, according to one embodiment. At step 202, the host device 102 determines rate of repetition of a particular command or set of commands. For example, if the host device 102 wishes to check device live status, the host device needs to send a same command to the storage device several times at regular time interval. To avoid this, the host device 102 determines rate of repetition based on the time interval so that the storage device 104 repeats the command by itself at the time interval. For example, the rate of repetition may be 10 milliseconds, if the host device 102 wants a command to be repeatedly processed every 10milliseconds. At step 204, the host device 102 computes number of commands to be executed by the storage device 104. For example, the host device 102 may have a read request which is bigger than one read unit command. In such case, the host device 102 determines number of times, the read unit command is to be executed based on size of the read request with respect to the size the read unit command. At step 206, the host device 102 generates a command indicating the rate of repetition and the number of commands to be executed. The command can be a read Universal Flash Storage Protocol Information Unit (UPIU) or a write UPIU.

At step 208, the host device 102 sends the command indicating the rate of repetition and the number of commands to be executed to the storage device 104. At step 210, the storage device 104 extracts the rate of repetition and the number of commands from the received command.

At step 212, the storage device 102 determines whether the command is to be repeatedly processed based on the rate of repetition indicated in the received command. If the command is to be processed for a single time, then at step 216, the storage device 104 processes the received command and sends a response based on the processed command at step 218.

If the command is to be repeatedly processed, then at step 214, the storage device 104 determines whether the time interval is elapsed for processing the command. If the time interval is elapsed, then at step 216, the storage device 104 repeats the command and processes the command. At step 218, the storage device 104 sends a response based on the execution of the command. If the time interval is not elapsed, then the storage device 104 repeats the step 214.

At step 220, the storage device 104 determines whether the received command is processed for a specified number of times based on the number of commands indicated in the received command. If the received command is processed for the specified number of times, at step 222, the storage device 104 sends a notification indicating that a particular command is executed for a specified number of times. If the received command is not processed for the specified number of times, then the storage device 104 repeats the steps 214 to 222. By performing the above steps 202 to 222, the host device 102 need not send multiple commands for same purpose as and when data is required, thereby reducing number of interrupts and eventually context switching.

Figure 3 is a flow diagram 300 illustrating an exemplary method of repeatedly processing storage commands, according to another embodiment. At step 302, the host device 102 determines rate of repetition of a particular command. At step 304, the host device 102 generates a command indicating the rate of repetition. At step 306, the host device 102 sends the command indicating the rate of repetition to the storage device 104.

At step 308, the storage device 104 extracts the rate of repetition from the received command. At step 310, the storage device 102 determines whether the command is to be repeatedly processed based on the rate of repetition indicated in the received command. If the command is to be processed for a single time, then at step 314, the storage device 104 processes the received command and sends a response based on the processed command at step 316.

If the command is to be repeatedly processed, then at step 312, the storage device 104 determines whether the time interval is elapsed for processing the command. If the time interval is elapsed, then at step 314, the storage device 104 repeats the command and processes the command. At step 316, the storage device 104 sends a response based on the execution of the command. In some embodiments, the storage device 104 may modify one or more fields specified by the host device 102 in the response. For example, the host device 102 indicates that a Logical Block Address (LBA) field (when LBA is sequential) is to be incremented every time a read command is repeated and executed. Accordingly, the storage device 104 increments the Logical Block Address (LBA) field in the response and sends the response to the host device 102.

If the time interval is not elapsed, then the storage device 104 repeats the step 312. After step 316, the storage device 104 returns to step 312 and repeatedly processes the commands based on the rate of repetition till a request to stop execution of the command from the host device 102.

Consider that the storage device 104 has processed the command repeatedly for desired number of times. Accordingly, at step 318, the host device 102 sends a request to stop repeated execution of the command. At step 320, the host device 102 stops repeated execution of the command based on the request.

Figure 4 is a schematic representation illustrating format 400 of a UPIU header, according to one embodiment. Particularly, the UPIU header 40o includes a Time/Rate Information (TI) field 402, a time field 404, a field identify (FI) field 406, a Modification Direction (MD) field 408, and a value field 410.

The TI field 402 indicates that a command needs to be repeated at a given time interval. The TI field 402 is 4 bits in size. For example, the TI field 402 is set to value ‘xx00b’ if the time field 404 is absent in the UPIU header 400. The TI field 402 is set to value ‘xx01b’ if the time field 404 indicates the time at which the command has to be executed. The TI field 402 is set to value ‘xx10b’ if the time field 404 indicates time out of the command. The TI field 402 is set to value ‘xx11b’ if the time field 404 indicates time interval between two successive repetitions of the command. If the TI field 402 is set to ‘xx11b’ then the host device 102 needs to send a request to stop the repetition of command to the storage device 104 as illustrated in Figure 3.

When the command is to be repeated, the time field 404 indicates time interval between two successive executions of command. The FI field 406 identifies a field to be modified by the storage device 104 after execution of the command each time. The MD field 410 indicates whether the field identified in the FI field 406 is to be modified (i.e., incremented, decremented, added or subtracted). The value field 410 includes a value by which the field indicated in the FI field 406 is to be modified. In some embodiments, the UPIU header 400 includes the FI field 406, MD field 408 and the value field 410 if the TI field 402 is set to the value ‘xx11b’. It can be noted that, the UPIU header 400 may also include a field to include a number of times a particular command is to be repeated. In this case, the host device 102 need not send a request to stop repetition of the command and the storage device 104 would automatically stop the repetition of the command upon processing the command for the specified number of times as illustrated in Figure 2.

Figure 5 is flow diagram 500 illustrating an exemplary method of processing of storage commands, according to yet another embodiment. At step 502, the host device 102 sends a write command with a preset time period (also known as wait time out) for performing a write operation at the storage device 104. The preset time period is a time period for which the storage device 104 can wait for data-out packet prior to entering an idle mode or processing another command. At step 504, the host device 102 sends the write command with the preset time period to the storage device 104. Alternatively, the host device 102 sends a common configuration descriptor with the preset time period to the storage device 104. At step 506, the storage device 104 adds the write command to a command queue. At step 508, the storage device 104 processes the write command in the command queue. At step 510, the storage device 104 sends a RTT to the host device 102.

At step 512, the storage device 104 determines whether any data-out packet is received from the pre-set time period. If no data-out packet is received within the preset time period, at step 514, the storage device 104 sends a failure notification to the host device 102. The failure notification may include the pre-set time period value or configuration descriptor value. At step 516, the storage device 104 terminates the write operation and moves to idle mode or process a next write command in step 518.

Figure 6 is a flow diagram 600 illustrating an exemplary method of processing storage commands, according to further another embodiment. At step 602, the host device 102 generates read commands for performing a read operation at the storage device 104. At step 604, the host device 102 determines time at which each read command is to be processed. At step 606, the host device 102 sends the read commands with association time information to the storage device 104.

At step 608, the storage device 104 postpones the read commands based on the time information. For example, if a read command 1 is to be executed immediately (0 sec), then the storage device 104 executes the read command 1 immediately. If the read command 2 is to be executed after 30 seconds, then the storage device 104 postpones the execution of the read command 2 by 30 seconds. At step 610, the storage device 104 continuously determines whether any postponed read command is due for processing. If the postponed read commands are due for processing, then at step 612, the storage device 104 processes the postponed read commands that are due to processing. At step 614, the storage device 104 sends a response message after processing the postponed read command and repeats the steps 610-614 till no read commands are due for processing. In some embodiments, when there are no read commands to be processed prior to the postponed read commands, the storage device 104 may intelligently processes the postponed read commands ahead of time and respective response messages to the host device 102.

Figure 7 is a flow diagram 700 illustrating an exemplary method of processing storage commands, according to yet a further embodiment. At step 702, the host device 102 generates a command with a request for attending/processing time. At step 704, the host device 102 sends the command with the request for attending/processing time to the storage device 104. At step 706, the storage device 104 adds the received command to a command queue.

At step 708, the storage device 104 determines time required to attend/process the received command. For example, the time required for attending/processing the received command based on number of commands to be processed in the command queue and the time required to process the commands queued ahead of the command queue. At step 710, the storage device 104 sends a response message (e.g., data-in packet, response UPIU, etc.) indicating the time required to attend/process the command. At step 712, the host device 102 modifies priority associated with the command. For example, the host device 102 may change the priority from low to high based on when the requested data is required. At step 714, the host device 102 sends a message with the modified priority of the command to the storage device 102. At step 716, the storage device 104 moves the command up in the command queue according to the modified priority and processes the command.

Figure 8 is a flow diagram 800 illustrating an exemplary method of processing storage commands, according to still embodiment. At step 802, the host device 102 generates a first command. At step 804, the host device 102 sends the first command to the storage device 104. At step 806, the storage device 104 adds the first command to a command queue.

At step 808, the host device 102 generates a second command with a request for time required to process the first command. At step 810, the host device 102 sends the second command with the request for time required to process the first command to the storage device 104. At step 812, the storage device 104 adds the second command to the command queue.

At step 814, the storage device 104 determines time required to process the first command. At step 816, the storage device 104 sends a response message (e.g., data-in packet, response UPIU, etc.) indicating the time required to process the first command. At step 818, the host device 102 modifies priority associated with the first command. For example, the host device 102 may change the priority from low to high based on whether the command is to be executed earlier than other commands. At step 820, the host device 102 sends a message with the modified priority of the first command to the storage device 102. At step 822, the storage device 104 processes the first command according to the priority modified by the host device 102.

Alternatively, the host device 102 may send a task management command requesting processing time information for a particular command using a task tag. Accordingly, the storage device 104 sends the processing time information to the host device 102.

Figure 9 is a schematic representation illustrating format 900 of a UPIU header including a request for time required to process a UPIU, according to one embodiment. The UPIU header 900 includes a task tag field 902, and a time information (TI) field 904.

The task tag field 902 indicates a request for time required to process a UPIU. The TI field 904 indicates action to be performed by the storage device 104. For example, the TI field 904 is set to a value ‘00xxb’ if the storage device 104 need not send information on processing time. The TI field 904 is set to a value ‘01xxb’ if time required to process the instant UPIU is desired. The TI field is set to ‘01xxb’ for the case illustrated in Figure 7. The TI field 906 is set to a value ‘10xxb’ if the time required to process the last UPIU is desired. Alternatively, an execution completion time field is used instead of the TI field 902. In such case, the task tag may not be required in the UPIU header 900.

For the case illustrated in Figure 9, the TI field 902 is set to ‘10xxb’. In one exemplary implementation, first two bits of the TI field 902 are used to indicate the action to be performed by the storage device 104 when the processing time information is requested by the host device 102. As shown in Figure 4, the remaining two bits of the TI field 904 indicate the meaning of the time field 906 when the UPIU needs to be repeatedly processed.

In some embodiments, the storage device 104 sends the time required to process a UPIU immediately in a time info UPIU packet upon receiving the UPIU. In these embodiments, the host device 102 sets a bit equal to 1 in the UPIU if immediate response is desired. An exemplary time info UPIU packet is illustrated in Figure 10. In other embodiments, the storage device 104 may send the time required to process the UPIU to the host device 102 in a response message (e.g., data-in response, response UPIU, etc.) corresponding to execution of other command. An exemplary response message corresponding to executed command is illustrated in Figure 11.

Figure 10 is a schematic representation illustrating format 1000 of a time info UPIU packet indicating time required to process the UPIU 900, according to one embodiment. The time info UPIU packet 1000 includes a time information (TI) field 1002, a time info packet field 1004 and a time field 1006. The TI field 1002 indicates the same value as of the TI field 902 of the UPIU. The time info packet field 1004 indicates that the UPIU packet corresponds to a time info UPIU packet. The time field 1006 indicates time required to process the UPIU 900.

Figure 11 is a schematic representation illustrating format 1100 of a response message indicating time required to process the UPIU 900, according to another embodiment. The response message 1100 is exemplary response message sent after processing other UPIU received from the host device 102. The response message 1100 may include the time information (TI) field 1102, a task tag 1104 and a time field 1106. The TI field 1102 indicates the same value as of the TI field 902 of the UPIU. The task rag field 1104 includes the task tag in the task tag field 902 of the UPIU 902 which requested the time information. The time field 1106 indicates time required to process the UPIU 900.

The present embodiments have been described with reference to specific example embodiments; it will be evident that various modifications and changes may be made to these embodiments without departing from the broader spirit and scope of the various embodiments. Furthermore, the various devices, modules, and the like described herein may be enabled and operated using hardware circuitry, for example, complementary metal oxide semiconductor based logic circuitry, firmware, software and/or any combination of hardware, firmware, and/or software embodied in a machine readable medium. For example, the various electrical structure and methods may be embodied using transistors, logic gates, and electrical circuits, such as application specific integrated circuit.