Techniques and tools for achieving improved test coverage in a finite program state space are described, such as a technique for selecting a set of predicates, calculating a set of possible predicate values, calculating a subset of the set of possible predicate values, and generating a test for the computer program based at least in part on the subset. The subset comprises an approximation (e.g., an under-approximation) of reachable states in the program. A superset of the set of possible predicate values also can be calculated; the superset comprises an over-approximation of the reachable states in the program. In another aspect, a Boolean abstraction of a program is generated, reachability analysis is performed based at least in part on the Boolean abstraction, and symbolic execution is performed to generate test data. The reachability analysis can include computing lower and/or upper bounds of reachable observable states.

Predicate-based test coverage and generation

A call-management method and system for distributing calls to agents, wherein each agent has a profile, e.g., defining agent skills, efficiency, etc. The call center management system implements an algorithm for selecting an agent to receive a call to optimize caller utility, call center efficiency, and agent training. Therefore, the algorithm does not seek to necessarily route a call to the agent having the skill set most suited to the call; rather, the call may be routed to an agent who needs experience in the area of the call, and thus serves as a training exercise. Skilled agents may be made available to shadow the training agent when available.

Agent training sensitive call routing system

Executing programs coded in an instruction set of a first computer on a computer of a second, different architecture. An operating system maintains an association between each one of a set of concurrent threads and a set of computer resources of the thread's context. Without modifying a pre-existing operating system of the computer, an entry exception is establishing to be raised on each entry to the operating system at a specified entry point or on a specified condition. The entry exception has an associated entry handler programmed to save a context of an interrupted thread and modify the thread context before delivering the modified context to the operating system. A resumption exception is established to be raised on each resumption from the operating system complementary to one of the specified entries. The resumption exception has an associated exit handler programmed to restore the context saved by a corresponding execution of the entry handler. The entry exception, exit exception, entry handler, and exit handler are cooperatively designed to maintain an association between a one of the threads and an extended context of the thread through a context change induced by the operating system, the extended context including resources of the computer associated with the thread beyond those resources whose association with the thread is maintained by the operating system.

Apparatus for executing programs for a first computer architechture on a computer of a second architechture

A dynamic compiler and method of compiling code to generate a dominate path and handle exceptions The dynamic compiler includes an execution history recorder that is configured to record the number of times a fragment of code is interpreted When the code is interpreted a threshold number of times, the code is queued for compilation The execution history recorder also keeps track of where transfer of control came from and where transfer of control goes to for each fragment of code that is executed, thereby allowing for compilation of a dominant path of code If the execution of code deviates from the dominant path of compiled code (such as when an exception occurs), a fallback interpreter is utilized to interpret the fragment of code to be executed

Dynamic compiler and method of compiling code to generate dominant path and to handle exceptions

A method (and system) of transparent dynamic optimization in a multiprocessing environment, includes monitoring execution of an application on a first processor with an execution monitor running on another processor of the system, and transparently optimizing one or more segments of the original application with a runtime optimizer executing on the another processor of the system.

Method and system for transparent dynamic optimization in a multiprocessing environment

An optimizing object code translation system and method perform dynamic compilation and translation of a target object code on a source operating system while performing optimization. Compilation and optimization of the target code is dynamically executed in real time. A compiler performs analysis and optimizations that improve emulation relative to template-based translation and interpretation such that a host processor which processes larger order instructions, such as 32-bit instructions, may emulate a target processor which processes smaller order instructions, such as 16-bit and 8-bit instructions. The optimizing object code translator does not require knowledge of a static program flow graph or memory locations of target instructions prior to run time. In addition, the optimizing object code translator does not require knowledge of the location of all join points into the target object code prior to execution. During program execution, a translator records branch operations. The logging of information identifies instructions and instruction join points. When a number of times a branch operation is executed exceeds a threshold, the destination of the branch becomes a seed for compilation and code portions between seeds are defined as segments. A segment may be incomplete allowing for modification or replacement to account for a new flow of program control during real time program execution.

Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method

PROBLEM TO BE SOLVED: To provide an object code conversion program which dynamically optimizes an object code by using an interpreter and a compiler which groups the instructions of the converting side object code into segments when the executing frequency of the corresponding branch instruction exceeds its threshold and compiles the segments dynamically. SOLUTION: An interpreter 110 and a compiler 104 communicate with each other in several methods. The interpreter 110 communicates with a branch logger 112 to record the branch information to a branch log and then converts the converting side object code into its corresponding converted object code and decides the executing frequency of the branch instructions of the converting side object code. The compiler 104 groups the instructions of the converting side object code into segments when the executing frequency of the corresponding branch instruction exceeds its threshold and then compiles dynamically these segments.

Computer architecture emulation system

: Viewgraphs from presentation on the use of streaming and dynamic compilers for high performance embedded computing

Streaming and Dynamic Compilers for High Performance Embedded Computing

The system emulates a source computer architecture on a target computer architecture. An interpreter device translates source object codes into corresponding translated object codes and determines a number of executions of branch instructions in the source object code. A compiler groups instructions of the source object in one segment if a number of executions of a corresponding branch instruction exceeds a threshold. An Independent claim is included for a computer architecture emulation system. A multi-task computer architecture emulation system is also claimed.

Computer architecture emulation system groups instructions of source object in one segment if number of executions of branch instruction exceeds threshold

Charles D. Garrett

Papers

Dynamic optimizing object code translator for architecture emulation and dynamic optimizing object code translation method

Computer architecture emulation system

Streaming and Dynamic Compilers for High Performance Embedded Computing

Computer architecture emulation system groups instructions of source object in one segment if number of executions of branch instruction exceeds threshold