# US 8,789,021 B2 · Method and apparatus for object-oriented load testing of computing systems

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 8,789,021 B2
- Document ID: US8789021B2
- Status: Granted
- Kind: B2
- Application number: 11/173,384
- Filed: 2005-06-30
- Published: 2007-01-04
- Granted: 2014-07-22
- Earliest claimed: 2005-06-30
- Assignees: International Business Machines Corporation
- Applicants: Kevin Mooney; David A. Scott
- Inventors: Kevin Mooney; David A. Scott
- Web page: https://patentgrep.com/patent/US8789021B2

## CPC

- G06F 9/4881: {Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues}
- G06F 11/3414: {Workload generation, e.g. scripts, playback}
- G06F 11/3495: {for systems}
- G06F 2201/875: Monitoring of systems including the internet
- G06F 2209/483: Multiproc
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Computer apparatus, method and system for developing, in an existing protocol, load tests of a computing system. The invention includes a kernel that provides a plurality of core actions for use in a subject load test script. Core actions employed in the subject load test script are implemented as respective kernel actions written in an object-oriented programming language underlying the existing protocol. An execution engine applies the subject load test script to a number of test clients. The execution engine schedules for execution and executes the kernel actions in a manner that utilizes a relatively small number of resources as compared to the number of test clients. An extender extends the protocol (e.g., extends the base classes of the protocol and/or adds features to the protocol), and the invention adds corresponding references to the subject load test script accordingly.

## Claims

### Claim 1

Computer apparatus for developing load tests of a computing system, the apparatus having an existing protocol and comprising:
a kernel in memory providing a plurality of core actions for use in a subject load test script, core actions employed in the subject load test script being implemented as respective atomic kernel actions that are specializations of the corresponding core actions that can be executed at will, the kernel being written in an object-oriented programming language underlying the existing protocol of the apparatus such that each individual kernel action is modeled as a respective object in the object-oriented programming language enabling different kernel actions to be treated equally in execution resources, and each kernel action being atomic and extensible;
an execution engine in working memory executed by a processor and applying the subject load test script to a number of test clients, the execution engine as executed by the processor scheduling for execution and executing the kernel actions, the kernel actions being able to be swapped into and out of executable states and individually executed at will and treated equally enabling a number of resources per number of kernel actions instead of per number of test clients, and resulting in use of a relatively small number of resources as compared to the number of test clients, wherein the relatively small number of resources is less than one thread per user emulated to generate a load, wherein the processor is free from creating a process for each test client and wherein the processor enables a plurality of kernel actions of different test clients in one process; and
an extender in memory operatively communicating with the kernel and extending the protocol including any combination of extending base classes of the protocol and adding features to the protocol,
the kernel enabling the subject load test script to be responsive to extensions of the protocol and adding corresponding references to the test script to be run resulting in, for a given kernel action, a new kernel action being executed in place of the given kernel action free of necessitating modification of the rest of the kernel.

### Claim 2 (depends on 1)

Computer apparatus as claimed in claim 1 wherein the execution engine swaps kernel actions into and out of execution space with a very small number of threads for a very large number of emulated users.

### Claim 3 (depends on 1)

Computer apparatus as claimed in claim 1 wherein the execution engine employs a plurality of queues that allow execution threads to execute any kernel action at any time.

### Claim 4 (depends on 3)

Computer apparatus as claimed in claim 3 wherein the queues are coupled in parallel.

### Claim 5 (depends on 1)

Computer apparatus as claimed in claim 1 wherein the object oriented programming language is JAVA.

### Claim 6

A method for developing, in an existing protocol, load tests of computing systems, the method comprising the computer implemented steps of:
providing in memory a kernel having a plurality of core actions for use in a subject load test script;
for core actions employed in the subject load test script, implementing the core actions as kernel actions that are specializations of the corresponding core actions that can be executed at will, and that are written in an object oriented programming language underlying the existing protocol such that each individual kernel action is modeled as a respective object in the object-oriented programming language enabling different kernel actions to be treated equally in execution resources, each kernel action being atomic and extensible; and
applying the subject load test script to a number of test clients including scheduling for execution and executing the kernel actions using a processor, the kernel actions being able to be swapped into and out of executable states and individually executed at will and treated equally enabling a number of resources per number of kernel actions instead of per number of test clients, resulting in use of a relatively small number of resources as compared to the number of test clients, wherein the relatively small number of resources is less than one thread per user emulated to generate a load, wherein the processor is free from creating a process for each test client and wherein the processor enables a plurality of kernel actions of different test clients in one process;
wherein the step of implementing the core actions as kernel actions includes:
extending base classes of the protocol; and
adding corresponding references to the subject load test script, resulting in, for a given kernel action, a new kernel action being executed in place of the given kernel action free of necessitating modification of rest of the kernel.

### Claim 7 (depends on 6)

A method as claimed in claim 6 further comprising the step of swapping kernel actions into and out of execution with a very small number of threads for a very large number of emulated users.

### Claim 8 (depends on 6)

A method as claimed in claim 6 wherein the step of executing further includes employing a plurality of queues to enable execution of any kernel action at any time.

### Claim 9 (depends on 6)

A method as claimed in claim 6 wherein the step of extending further includes adding features to the protocol.

### Claim 10 (depends on 6)

A method as claimed in claim 6 wherein the object oriented programming language is JAVA.

### Claim 11

A computer program product comprising a non-transitory computer usable storage medium including computer usable program code stored thereon for developing, in an existing protocol, load tests of computing systems, said computer program product being non-transitory and including:
computer usable program code for providing a kernel having a plurality of core actions for use in a subject load test script;
for core actions employed in the subject load test script, computer usable program code for implementing the core actions as kernel actions that are specializations of the corresponding core actions that can be executed at will, and that are written in an object oriented programming language underlying the existing protocol such that each individual kernel action is modeled as a respective object in the object-oriented programming language enabling different kernel actions to be treated equally in execution resources and each kernel action being atomic and extensible;
computer usable program code for applying the subject load test script to a number of test clients, including scheduling for execution and executing the kernel actions using a processor, the kernel actions being able to be swapped into and out of executable states and individually executed at will and treated equally enabling a number of resources per number of kernel actions instead of per number of test clients, and resulting in use of a relatively small number of resources as compared to the number of test clients, wherein the relatively small number of resources is less than one thread per user emulated to generate a load, wherein the processor is free from creating a process for each test client and wherein the processor enables a plurality of kernel actions of different test clients in one process;
computer useable program code for extending base classes and/or adding features of the protocol; and
computer useable program code for automating addition of corresponding references to the subject load test script, resulting in, for a given kernel action, a new kernel action executed in place of the given kernel action free of needing to modify rest of the kernel.

### Claim 12 (depends on 11)

A computer program product as claimed in claim 11 further comprising computer usable program code for swapping kernel actions into and out of execution with a very small number of threads for a very large number of emulated users.

### Claim 13 (depends on 11)

A computer program product as claimed in claim 11 wherein the object oriented programming language is JAVA.

### Claim 14

A computer system for developing, in an existing protocol, load tests of computing systems, comprising:
kernel means in memory providing a plurality of kernel actions for use in a subject load test script, the kernel actions being executable at will specializations of core actions stored in memory, the kernel actions being written in an object-oriented programming language underlying the existing protocol such that each individual kernel action is modeled as a respective object in the object-oriented programming language enabling different kernel actions to be treated equally in execution resources including threads and processes, and each kernel action being atomic and extensible;
execution means executable by a processor for applying the subject load test script to a number of test clients, the execution means scheduling for execution and executing the kernel actions, the kernel actions being able to be swapped into and out of executable states and individually executed at will and treated equally enabling a number of resources per number of kernel actions instead of per number of test clients, and resulting in use of a relatively small number of resources as compared to the number of test clients, the relatively small number being on the order of less than one thread per user emulated to generate a load, wherein the processor is free from creating a process for each test client and wherein the processor enables a plurality of kernel actions of different test clients in one process; and
extension means in memory operatively communicating with the kernel means for extending the protocol including any combination of extending base classes of the protocol and adding features to the protocol,
wherein the kernel means enables corresponding references to extensions of the protocol to be automatically added to the subject load test script, resulting in, for a given kernel action, a new kernel action being executed in place of the given kernel action free of modifying rest of the kernel means.

### Claim 15 (depends on 14)

A computer system as claimed in claim 14 wherein the execution means swaps kernel actions into and out of execution with a very small number of threads for a very large number of emulated users.

### Claim 16 (depends on 14)

A computer system as claimed in claim 14 wherein the execution means employs a plurality of queues that allow execution threads to execute any kernel action at any time.

### Claim 17 (depends on 14)

A computer system as claimed in claim 14 wherein the object oriented programming language is JAVA.