System and methods for network call load simulation

• US 7,478,018 B1
• Filed: 09/30/2004
• Issued: 01/13/2009
• Est. Priority Date: 09/30/2004
• Status: Active Grant

• Current Assignee: Emc IP Holding Company LLC (Dell Technologies Inc.)
• Original Assignee: EMC Corporation (Dell Technologies Inc.)
• Inventors: Frazer, Sean P., Lavallee, James E., Dubrovsky, Alexander
• Primary Examiner(s): FREJD, RUSSELL WARREN
• Application Number:
  US10/955,964
• Time in Patent Office: 1,566 Days
• Field of Search: 703/2, 703/15, 717/104, 379/27.02, 379/29.02, 379/266.03, 709/202, 709/201, 709223-225, 707/102, 707/10, 707/200
• US Class Current: 703/2
• CPC Class Codes: H04L 41/046 comprising network management agents or mobile agents therefor
• CPC Class Codes: H04L 41/5009 Determining service level performance parameters or violations of service level contracts, e.g. violations of agreed response time or mean time between failures [MTBF]
• CPC Class Codes: H04L 43/50 Testing arrangements
• CPC Class Codes: H04L 67/1097 for distributed storage of data in networks, e.g. transport arrangements for network file system [NFS], storage area networks [SAN] or network attached storage [NAS]

Abstract

Configurations of the invention simulate an exchange of calls emanating from a SAN management application to a plurality of manageable entities. The simulated call load provides simultaneous simulated calls for observing and analyzing responses to various loading scenarios characterized by multiple pending calls to the SAN. Configurations discussed herein identify a processing work burden and corresponding completion time associated with each of the simulated calls. A simulation agent aggregates the work burden of concurrent requests and computes a latency factor associated with each call based on the load presented by all pending calls. By adjusting the latency time of each pending call, and adjusting the latency to represent the additional processing imposed by successive pending calls, the simulated responses provide an accurate set of responses, rather than merely returning an unencumbered rapid response of expected content which may elusively represent the actual timeliness of responses in a loaded system.

Claims

1. A method of simulating responses to request calls in a computer comprising:

receiving a call to perform a task by a simulation agent;

identifying currently pending requests operable for concurrent processing by the simulation agent;

computing, based on a collective load burden of the identified currently pending requests, a completion time for the processing of the received task call including determining a contention period for each interval during which a fixed number of currently pending requests are executing concurrently with the received task;

recalculating, based on the received call, the completion time of the currently pending requests; and

transmitting a response to the received task call at the recalculated completion time, the computer responsive to the transmitted response for invoking instructions.

2. The method of claim 1 further comprising:

receiving successive task calls requesting an associated response;

recalculating the completion time of each of the currently pending requests; and

transmitting the associated response for each of the currently pending requests at the corresponding recalculated completion time.

3. The method of claim 1 wherein computing the completion time of the received task call further comprises:

computing, for each contention period, the work burden completed for the received task by dividing the duration of the interval by the number of concurrent tasks and the received task contending for processing.

4. The method of claim 3 wherein recalculating the completion time further comprises:

identifying, for each contention period, the number of concurrent tasks; and

extending the completion time for each of the currently executing tasks by dividing the processing for each contention period by the number of concurrent tasks.

5. The method of claim 1 wherein computing further comprises computing a contention period, the contention period corresponding to a period of simultaneous processing by a set of tasks.

6. The method of claim 5 wherein computing the contention period further comprises:

identifying, from among the currently executing tasks, an end time of the earliest completing task;

identifying the start time for the received task; and

delimiting the contention period by computing the interval from the start time of the received task to the end time of the earliest completing task.

7. The method of claim 6 wherein identifying the end time of the earliest completing task further comprise:

estimating an end time of the received task based on the number of currently executing tasks and the processing burden of the received task;

recalculating the end time of the currently executing tasks based on the additional processing corresponding to the received task;

comparing each of the end times of the received task and the currently executing tasks; and

denoting the earliest of the compared end times as the end time of the earliest completing task.

8. The method of claim 7 wherein recalculating further comprises:

determining the number of executing tasks including the addition of the received task;

computing, for each of the currently executing tasks, an amount of work performed in the contention period; and

extending the completion time for each of the currently executing tasks based on the computed work performed.

9. The method of claim 1 wherein the received task and currently executing tasks are concurrently contending tasks, further comprising:

determining a contention section indicative of a fixed number of concurrently contending tasks;

computing, for the determined contention section, an amount of work burden completed for reach of the concurrently contending tasks;

identifying the end of the contention section by completion of one of the contending tasks; and

iterating the determining, computing, and identifying until the remaining work burden for the received task is zero.

10. The method of claim 9 wherein the tasks further comprise non-breakable tasks, each of the non-breakable tasks indicative of a set of sequential atomic operations, wherein the contention period correspond to the processing of a current task of the currently executing tasks.

11. The method of claim 9 wherein the processing further comprises allocating processing among the work burden of the currently pending tasks in equal time slices.

12. A method of simulating processing contention comprising:

receiving a new task

identifying pending tasks in concurrent contention with the new task calculating an estimated completion time for the new task;

calculating completion time for each of the pending tasks;

identifying a time until the earliest of the calculated completion time as the contention period;

extending the processing time of each of the current tasks during the contention period based on the addition of the new task;

computing remaining processing to be performed on the new tasks;

establishing, if there is no remaining processing to be performed on the new task, the end of the current contention period as the completion time for the new task; and

identifying the next successive termination of the new task and the pending tasks as the current contention period;

repeating the recalculating of completion times, extending the processing time, and computing remaining processing on the new task until the remaining processing on the new task is complete.

13. A method for processing storage area network resource access requests, the method comprising:

receiving a storage area network resource access request for access to a simulated resource within a simulated storage area network environment;

calculating a resource access response time that simulates contention for access to the simulated resource by other resource requests;

preparing a resource access response to the storage area network resource access request based on a contention period indicative of the calculated resource access response time; and

forwarding the resource access response at the calculated resource access response time.

14. The method of claim 13 wherein receiving a storage area network resource access request comprises:

receiving a plurality of resource access requests from a storage area network management application that operates in conjunction with the simulated storage area network environment;

queuing each of the received resource access requests for preparation and forwarding of the resource access response at calculated resource access response times respectively calculated for each resource access request; and

wherein calculating a resource access response time comprises;

computing the resource access response time based upon;

i) a number of concurrently co-pending resource access requests;

ii) an amount of work to be performed by each of the concurrently co-pending resource access requests.

15. A computing device for simulating responses to a request call load comprising:

a simulation agent for receiving a call to perform a task, the simulation agent operable as an emulated resource;

a processing queue operable for identifying currently pending requests operable for concurrent processing by the simulation agent;

a latency simulator operable for computing, based on a collective load burden of the identified currently pending requests, a completion time for the processing of the received task call; and

scheduling logic in the latency simulator for recalculating, based on the received call, the completion time of the currently pending requests, the scheduling logic further operable to determine a contention period for each interval during which a fixed number of currently pending requests are executing concurrently with the received task, the latency simulator transmitting a response to the received task call at the computed completion time, the computing device responsive to the transmitted response for invoking instructions.

16. The computing device of claim 15 wherein the latency simulator is further operable to receive successive task calls requesting an associated response, and invoke the scheduling logic to recalculate the completion time of each of the currently pending requests, the latency simulator further operable to transmit the associated response for each of the currently pending requests at the corresponding recalculated completion time.

17. The computing device of claim 15 wherein the scheduling logic is further operable to compute, for each contention period, the work burden completed for the received task by dividing the duration of the interval by the number of concurrent tasks and the received task contending for processing.

18. The computing device of claim 17 wherein the scheduling logic is further operable to:

identify, for each contention period, the number of concurrent tasks; and

extend the completion time for each of the currently executing tasks by dividing the processing for each contention period by the number of concurrent tasks.

19. The computing device of claim 15 wherein the scheduling logic is operable to compute a contention period, the contention period corresponding to a period of simultaneous processing by a set of tasks.

20. The computing device of claim 19 wherein the scheduling logic is operable to:

identify, from among the currently executing tasks, an end time of the earliest completing task;

identify the start time for the received task; and

delimit the contention period by computing the interval from the start time of the received task to the end time of the earliest completing task.

21. The computing device of claim 20 wherein the scheduling logic is operable to:

estimate an end time of the received task based on the number of currently executing tasks and the processing burden of the received task;

recalculate the end time of the currently executing tasks based on the additional processing corresponding to the received task;

compare each of the end times of the received task and the currently executing tasks; and

denote the earliest of the compared end times as the end time of the earliest completing task.

22. The computing device of claim 21 wherein the scheduling logic is further operable to:

determine the number of executing tasks including the addition of the received task;

compute, for each of the currently executing tasks, an amount of work performed in the contention period; and

extend the completion time for each of the currently executing tasks based on the computed work performed.

23. The computing device of claim 15 wherein the received task and currently executing tasks are concurrently contending tasks, the scheduling logic further operable to:

determine a contention section indicative of a fixed number of concurrently contending tasks;

compute, for the determined contention section, an amount of work burden completed for reach of the concurrently contending tasks;

identify the end of the contention section by completion of one of the contending tasks; and

iterate the determining, computing, and identifying until the remaining work burden for the received task is zero.

24. The computing device of claim 23 wherein the tasks further comprise non-breakable tasks, each of the non-breakable tasks indicative of a set of sequential atomic operations, wherein the contention period correspond to the processing of a current task of the currently executing tasks.

25. The computing device of claim 23 wherein the scheduling logic is operable to allocate processing among the work burden of the currently pending tasks in equal time slices.

26. A computer program product having a computer readable medium operable to store computer program logic embodied in computer program code encoded as a set of instructions thereon which, when executed by a processor in a computer responsive to the instructions, cause the computer to perform steps for simulating responses to request calls comprising:

receiving a call to perform a task by a simulation agent;

identifying currently pending requests operable for concurrent processing by the simulation agent;

computing, based on the collective load burden of the identified currently pending requests, a completion time for the processing of the received task call;

recalculating, based on the received call, the completion time of the currently pending requests;

transmitting a response to the received task call at the recalculated completion time;

receiving successive task calls requesting an associated response;

recalculating the completion time of each of the currently pending requests; and

transmitting the associated response for each of the currently pending requests at the corresponding recalculated completion time, the computer responsive to the transmitted response for invoking instructions.

27. A computer program on a computer readable storage medium having program code including a set of instructions, which when executed by a computer, perform a method for simulating responses to request calls, the method comprising:

receiving a call to perform a task by a simulation agent;

identifying currently pending requests operable for concurrent processing by the simulation agent;

computing, based on the collective load burden of the identified currently pending requests, a completion time for the processing of the received task call including determining a contention period for each interval during which a fixed number of currently pending requests are executing concurrently with the received task;

recalculating, based on the received call, the completion time of the currently pending requests; and

transmitting a response to the received task call at the recalculated completion time, the computer responsive to the transmitted response for invoking instructions.

28. A simulator device having program code on a computer readable storage medium, the code including a set of instructions, which when executed on a computer, perform steps for simulating responses to request calls to nodes in a storage area network comprising:

means for receiving a call to perform a task by a simulation agent;

means for identifying currently pending requests operable for concurrent processing by the simulation agent;

means for computing, based on the collective load burden of the identified currently pending requests, a completion time for the processing of the received task call including determining a contention period for each interval during which a fixed number of currently pending requests are executing concurrently with the received task;

means for recalculating, based on the received call, the completion time of the currently pending requests; and

means for transmitting a response to the received task call at the recalculated completion time, the node responsive to the transmitted response for invoking instructions.