Abstract: Provided are techniques for receiving an error inject script that describes one or more error inject scenarios that define under which conditions at least one error inject is to be executed and compiling the error inject script to output an error inject data structure. While executing code that includes the error inject, an indication that an event has been triggered is received, conditions defined in the one or more error inject scenarios are evaluated using the error inject data structure, and, for each of the conditions that evaluates to true, one or more actions defined in the error inject script for the condition are performed.

Abstract: A scheduler receives a job graph which includes a graph of computational vertices that are designed to be executed on multiple distributed computer systems. The scheduler queries a graph manager to determine which computational vertices of the job graph are ready for execution in a local execution environment. The scheduler queries a cluster manager to determine the organizational topology of the distributed computer systems to simulate the determined topology in the local execution environment. The scheduler queries a data manager to determine data storage locations for each of the computational vertices indicated as being ready for execution in the local execution environment. The scheduler also indicates to a vertex spawner that an instance of each computational vertex is to be spawned in the local execution environment based on the organizational topology and indicated data storage locations, and indicates to the local execution environment that the spawned vertices are to be executed.

Abstract: A method and apparatus for locating errors is disclosed. A computer inserts an object reference into program code suspected of causing an error, the object reference having an initial class name. Responsive to execution of the program code, the computer generates a new class name for the object reference comprising the context information. The computer sets an object with the new class name as the object reference inserted into the program code suspected of causing the error, wherein the new class name of the object is located in computer memory in use by the executing program code. The computer then creates a record of the computer memory in use by the executing program code, the record including the context information in the form of the new class name of the object.

Abstract: A mechanism for generating backtracing information for software debugging of software programs running on virtual machines. A method of embodiments of the invention includes probing a virtual machine of a computer system, the virtual machine to run a software program, accessing compiler-generated output at a storage medium of the computer system, the compiler-generated output having debug information relating to the virtual machine, and obtaining the debug information from the compiler-generated output. The method further includes generating backtracing information of the software program using the debug information, and providing the backtracing information for debugging of the software program.

Abstract: Based on a requested allocation of a managed object, a native memory required with the managed object is determined. A portion of native memory is allocated and a portion of managed memory is allocated based on requirements of the managed object. A memory management strategy is implemented based on the allocation of native memory and unmanaged memory. For example, the memory management strategy can comprise garbage collection of first managed objects that have only managed heap associated therewith is performed before garbage collection of second managed objects that have both managed heap and native memory associated therewith.

Abstract: Systems, methods, and apparatus for automatically parallelizing code segments are provided. For example, an environment includes a profiling agent, a parallelization agent, and a verification agent. The profiling agent executes a code segment and generates a profile of the executed code segment. The parallelization agent analyzes the code segment to determine whether a parallelizable portion is present in the code segment. When a parallelizable portion is present, the parallelization agent determines, based on the profile of the executed code segment, whether to parallelize the parallelizable portion of the code segment. If it is determined to parallelize the parallelizable portion of the code segment, the parallelization agent automatically parallelizes the parallelizable portion of the code segment. The verification agent verifies the functionality and/or correctness of the parallelized code segment.

Abstract: The present invention is a system to develop mobile applications from a mobile device that includes a database with a memory, a hosting space, an app-creation application with a plurality of options stored on a mobile application repository on said memory over a communications network or within the mobile device. A client device downloads and installs the app-creation application from the mobile applications repository over a communications network to create said mobile applications. There are four methods for mobile application development created by the mobile device that utilize this system.

Abstract: An aspect of the present invention facilitates identification of test cases to be run after changes to modules of a software application. In one embodiment, a reference data is generated by inspecting the instructions (static analysis) forming the modules of the software application, with the reference data specifying a corresponding set of modules in the application that are referenced by each of the modules in the application. The reference data is then examined to find a referencing set of modules which reference any of the changed modules either as immediate reference or multi-level reference through other modules. Test cases invoking any of the modules in the referencing set are identified as suitable test cases to be run.

Abstract: Methods, apparatuses, and computer program products are provided for acquiring guest operating system instrumentation information in a hypervisor. Embodiments include receiving from a platform management application, by a hypervisor communication module of the hypervisor, a platform request for guest operating system instrumentation information associated with at least one guest operating system executing within the hypervisor; in response to receiving the platform request for the guest operating system instrumentation information, retrieving through shared memory between the hypervisor and the guest operating system, by the hypervisor communication module, the guest operating system instrumentation information associated with the at least one guest operating system; and transmitting, by the hypervisor communication module, the guest operating system instrumentation information to the platform management application.

Abstract: Widgets or other code modules for applications written in structured languages such as HTML can be tested advantageously by separating the extraction and validation logic. To test the functionality of a widget in response to an action, widget features of interest are identified. Context and feature nodes for these features are extracted from a page tree structure to generate a property vector that is representative of the state of the widget. After performing the action, context nodes for the features are attached to the new page tree for the newly loaded page, and an observed property vector is generated that represents the state of the widget after the action. The previous property vector is used with updated state information to generate an expected property vector. The observed property vector is compared with the expected property vector, and if the vectors match the validation is claimed to be successful.

Abstract: In one embodiment, a method of batch processing electronic data is provided. The method includes identifying one or more batch processing features common to a plurality of batch processing applications. The method also includes defining software code for managing execution of the common batch processing features, integrating the software code into at least one of the batch processing applications, and defining and taking one or more checkpoints. Moreover, the method includes retrieving input data in response to control data, processing at least a portion of the input data, determining the time of an error in response to the error during processing, retrieving data stored at the most recent one of the checkpoints, and processing at least a portion of the retrieved checkpoint data.

Abstract: Disclosed are various embodiments for replication of machine instances in a computing environment. A clone machine instance is instantiated from a machine image associated with an original machine instance. A stored execution state of the original machine instance is applied to the clone machine instance. At least a portion of a series of stored events received by the original machine instance is applied to the clone machine instance.

Abstract: Methods and systems to test of web browser enabled applications are disclosed. In one embodiment, a browser application can allow a user to perform test and analysis processes on a candidate web browser enabled application. The test enabled browser can use special functions and facilities that are built into the test enabled browser. One implementation of the invention pertains to functional testing, and another implementation of the invention pertains to pertains to site analysis.

Abstract: A server device is configured to receive a request to identify a manner in which changed code propagates within an application; generate a group of blocks that correspond to code associated with a parent function corresponding to the application and which includes the changed code; perform an intra-procedural analysis on the group of blocks to identify a block that is affected by the changed code included within an epicenter block; perform an inter-procedural analysis on functions associated with the block, where, when performing the inter-procedural analysis, the server device is to generate another group of blocks associated with the functions, and identify another block that is affected by the changed code included within the epicenter block; and present, for display, information associated with the block or the other block that enables the application to be tested based on the block or the other block.

Abstract: According to an example implementation, a computer-readable storage medium, computer-implemented method and a system are provided to receive a first class, the first class indirectly implementing a first interface, wherein the first class extends a second class that directly implements the first interface, identify one or more directly implemented methods within the first class, determine a method signature for one or more of the directly implemented methods, estimate that the first class indirectly implements the first interface based on the method signatures for the one or more directly implemented methods, and instrument the first class based on the estimating that the first class indirectly implements the first interface.

Abstract: A technique includes providing first objects that are associated with an application session and in a processor-based system, identifying second objects in another application session corresponding to the first objects based at least in part on a comparison of the second objects to matching rules associated with the first objects.

Abstract: A user can control when data sampling takes place, what data is collected and where in the code the data sampling profiler is invoked. By identifying a section of user code to the profiler, the profiler is instructed to dynamically instrument the identified user code executing in a target application process. The instrumentation invokes the profiler before or after or both before and after the identified section of user code is executed. By identifying an entry point of a component or technology external to the user code, the profiler is instructed to dynamically instrument the external component so that data sampling is logged when the user code calls the entry point of the external component. The data sampling process can be monitored and the sampling rate can be dynamically adjusted.

Abstract: A system and method configured to instrument code for in-production monitoring provides a polling thread. A main thread executes the code of an instrumented application program and the polling thread executes in the background. Therefore the polling thread does not reduce the performance of the application program execution while monitoring activities are performed. Additionally, the polling thread is configured to simplify the process of instrumenting code for Java management extensions (JMX) by navigating the application program structure to locate administrative objects to bind to JMX and registering the administrative objects with JMX to enable monitoring of the instrumented code.

Abstract: A system and method are provided to customize profiling sessions. In one embodiment, a profiling session at a first virtual machine is initiated, the profiling session including tracking a profiling event occurring at threads, each thread having associated semantical information corresponding to a plurality of profiling entities. A request from a second virtual machine is received specifying extracting profiling information when a profiling entity executes a thread where the profiling event occurs. The profiling information relating to the profiling entity is extracted as requested by the second virtual machine. The profiling information is communicated to the second virtual machine.

Abstract: A method of debugging a function upon function exit includes pausing program execution at the time of initializing the function, wherein the function initialization includes saving a set of registers on the stack, recording the value of the stack pointer, configuring a watchpoint register based on the recorded value, wherein the watchpoint register is configured to trap memory references of the function based on the recorded value of the stack pointer, and executing the function. Program execution will pause when it is exiting the function because of stack references made by the function epilogue to restore registers saved on the stack and the configured watchpoint registers.

Abstract: Reusable JSP code snippets are defined and instrumented for Website testing and production. A user may define tile definitions in a markup language file for a number of JSP code snippets to be included in a store page. Upon receiving store inputs comprising tile definitions and jar files for the features, tables may be generated that map features to stores and features dependencies to features. Based on the tables, the store inputs may be validated. If no error occurs, run time files may be generated and JSP code snippets may be instrumented to the appropriate location for Website testing and production.

Abstract: The present disclosure relates to a computer-implemented method for abstract software performance profiling. The method may include providing, using a computing device, a virtual run-time stack associated with a software performance profile. The method may further include generating, using the computing device, at least one abstract tag associated with the virtual run-time stack. The method may also include performing, using the computing device, at least one operation on the virtual run-time stack, the at least one operation including, at least in part, the at least one abstract tag.

Abstract: An improved system and method for profiling elements of software applications facilitates identification and diagnosis of performance issues. Using aspect-oriented programming, additional code, referred to as an advice, is added at various steps in execution of a stored procedure. The additional code specifies additional action to be taken, such as capture of a stored procedure signature, parameters, and system time before and after execution. By adding the code at load time, the system of the present invention provides a mechanism by which the original procedure code as stored in the database and the application code calling the stored procedure can remain unchanged. Captured data is used in generating a profile of the stored procedure call.

Abstract: Method and apparatus are provided for a synchronizing execution of a plurality of threads on a multi-threaded processor. Each thread is provided with a number of synchronization points corresponding to points where it is advantageous or preferable that execution should be synchronized with another thread. Execution of a thread is paused when it reaches a synchronization point until at least one other thread with which it is intended to be synchronized reaches a corresponding synchronization point. Execution is subsequently resumed. Where an executing thread branches over a section of code which included a synchronization point then execution is paused at the end of the branch until the at least one other thread reaches the synchronization point of the end of the corresponding branch.

Abstract: Various technologies and techniques are disclosed for providing a debugger for programs running under a transactional memory system. When running a particular program using the debugger, the system detects when a conflict occurs on at least one conflictpoint that was set in the particular program. A graphical user interface is provided that displays information related to the detected conflict. The graphical user interface can display transactional state and/or other details independently of a conflict. A conflictpoint can be assigned to one or more regions of source code in one or more transactions in the particular program. A conflictpoint can also be assigned to a particular variable in the particular program. When running the particular program in a debug mode, execution is stopped if a conflict occurs on any of the conflictpoints.

Abstract: Methods and devices for controlling access to resources are disclosed herein.

Abstract: A system and method of deriving software use and software data object characteristics determine one or more locations on one or more computer storage devices where one or more configuration and data files associated with computer software components are stored, and obtain one or more attributes associated with said one or more computer software components. One or more commands associated with said one or more computer software components may be issued and one or more related information associated with said one or more software computer components resulting from issuing one or more commands may be collected. The related information and the one or more attributes may be mapped to the computer software components to derive information about the computer software component use and data object use characteristics.

Abstract: In one embodiment the present invention includes a computer-implemented method of measuring bottlenecks in a computer program implemented in a hardware client-server environment. The method includes defining an execution parameter to measure of the hardware client-server environment. The method further includes modifying code blocks to include instrumentation code. The instrumentation code relates to the execution parameter. The method further includes executing, in the hardware client-server environment, the code blocks having been modified. The method further includes generating instrumentation data, related to the execution parameter, that result from executing the code blocks. The method further includes outputting the instrumentation data having been generated. In this manner, the bottlenecks may be measured; the measured bottlenecks may be sorted; noteworthy bottlenecks may be identified; and the aspects of the hardware client-server environment may be adjusted to address the bottlenecks.

Abstract: A method and apparatus for monitoring software events in a computer system comprises a plurality of processors each performing a portion of an overall system task. Each processor has an application portion having one or more threads for performing the portion of the overall task and an application program interface for receiving notification of an event within the portion and transferring data relevant to the overall task portion and indication of occurrence of the event to a common hardware module that time stamps and stores the time of event, the origin of the relevant data, and the relevant data, time stamping being achieved using a highly accurate clock. The system can then send a record of the event, accurately time stamped at the very time of its occurrence, to a remote monitoring site for later assessment.

Abstract: A method for processing a probe including triggering the probe in an instrumented program, querying a global array to determine an execution control block associated with the probe, and executing the execution control block to obtain data.

Abstract: A method for concurrent management of adaptive programs is disclosed wherein changes in a set of modifiable references are initially identified. A list of uses of the changed references is next computed using records made in structures of the references. The list is next inserted into an elimination queue. Comparison is next made of each of the uses to the other uses to determine independence or dependence thereon. Determined dependent uses are eliminated and the preceding steps are repeated for all determined independent uses until all dependencies have been eliminated.

Abstract: Computer code for a mock object is automatically generated and used in testing computer program code. Interactions with a method of an object that is described by the computer program code are captured. From the captured interactions, mock code that creates a mock object is automatically generated. The mock object mimics the captured interactions. Subsequently, test code, which has at least some of the computer program code and mock code, is executed to enable testing of the computer program code.

Abstract: Methods and apparatus for testing user interfaces are disclosed herein. An example method includes extracting object data from a file associated with a user interface; storing a plurality of object definitions corresponding to the extracted object data in a computer readable storage medium; and generating, at a computer having a tangible memory, a test script for the user interface using the object definitions, wherein the test script is to be generated based on one or more test definitions defining one or more attributes of the object definitions to be tested in the test script, and wherein the test script is to be generated based on one or more automation rules defining how the object definitions are to be tested.

Abstract: There is provided an autonomic software system and method for normalizing a profile collected for an executing application to account for one or more actions applied to the executing application after the profile was collected, comprising: predicting an impact of applying the one or more actions to the executing application by utilizing the profile and the one or more actions; and adjusting the profile to form a normalized profile according to the predicted impact. A plurality of different a profile consumers, such as, a phase shift detector, an action evaluator as well as a normalizing controller, may utilize the normalized profile to improve the behavior of the executing application. In addition, online visualization tools may be implemented to graphically depict the normalized profiles, as well as differences between the collected profiles and the normalized profiles.

Abstract: An apparatus and method provide for profile optimizations at a binary level. Thread specific data may be used to lay out a procedure in a binary. In one example, a hot thread may be identified and a layout may be generated based on the identified hot thread. Also, threads of an application may be ranked according to frequency of execution of the corresponding threads. The layout may be created based on the different threads of differing frequency of execution and conflicts between a hottest thread and each of the other threads of the application. In another example, different threads of the application may conflict. For example, two threads may contain operations that overlap temporally to create a race condition. A layout of the application threads may be created based on conflicting threads.

Abstract: An introspection tool monitors the execution of software. The operating system is being executed using an executable of a software source code file. The software source code file is associated with one or more additional source files. The introspection tool detects a trigger in a user script pertaining to monitoring of the execution of the software. The introspection tool identifies an additional source file that corresponds to the trigger in the user script and causes the additional source file to be compiled. The compiling of the additional source file generates debug information that pertains to the trigger and the introspection tool analyzes the debug information to respond to the trigger in the user script.

Abstract: Monitoring resources of a computing device during testing of software applications provides useful feedback to developers and implementers of the software application. By periodically collecting system counter data during automated testing of the software application, and correlating the collected data to a state of the test, the actions of the test causing any undesirable resource issues can be readily identified.

Abstract: The tool, MC/DC-Automatic Tool Generator automatically generates test data to satisfy Modified Condition Decision Coverage (MCDC) from input code/model. This tool reduces the effort required to generate MCDC test data significantly. In order to reduce the time required by model checkers, abstraction and optimization methodologies have been implemented to analyze typical reactive software model/code.

Abstract: This invention enables a target variable name to be confirmed without inputting all the character string even when a method of giving a name such as allocating a number to the end of the name is performed from the necessity to allocate a variable name having the same meaning to a plurality of different addresses. If narrowed down variable name exists in plurals and one or two or more continuous next character strings match each other among the variable names, the series of character strings without any choice are automatically adopted and confirmed as the character string of the target variable name without waiting for the input of an operator.

Abstract: A method for testing software may include receiving a user request to run a test, and identifying a test flow document associated with the test. The test flow document may specify a plurality of test steps and define a test flow for the test. Each of the plurality of test steps may correspond to an independently-compiled set of instructions. The method may further include executing the plurality of test steps using dependency injection provided in accordance with the defined test flow.

Abstract: An apparatus comprising a first core of a multi-core processor, a second core of a multi-core processor and a bus matrix. The first core may be configured to communicate through a first input/output port. The first core may also be configured to initiate a testing application. The second core may be configured to communicate through a second input/output port. The second core may also be configured to respond to the testing application. The bus matrix may be connected to the first input/output port and the second input/output port. The bus matrix may transfer data between the first core and the second core. The testing application may generate real-time statistics related to the execution of instructions by the second core.

Abstract: A profiler may be detached from an actively running application by first sealing communications between the application and profiler, then evacuating the profiler by waiting for any profiler-modified or instrumented code to complete execution, profiler runtime code to complete execution, cleaning up any residual items from the profiler, and shutting down the profiler. The profiler may be operational in many different environments, including a managed environment such as a virtual machine and those environments having just in time compiling of executable code.

Abstract: A method for utilizing an instrumented application in a mobile device environment. The method includes instrumenting an application to generate an instrumented application configured for use in the mobile device environment, obtaining authorization from a governing body for use of the instrumented application in the mobile device environment, and directing the instrumented application to cause a mobile device to operate according to a first setting. The first setting is invoked without requiring further authorization by the governing body.

Abstract: A method and system for generating and processing test cases for effective black box testing of software applications is provided. Test cases are automatically generated based on parameters that are identified from automated manual test cases associated with business models. The generated automated test cases cover one or more paths in the business models. Further, the automated test cases are optimized by determining minimal path covered by the automated test cases in the business models. The optimization is performed based on analysis of the one or more paths covered by the automated test cases in the business models. Furthermore, code coverage data of the optimized test cases are obtained by execution of the optimized test cases. Finally, based on the code coverage data and predetermined conditions, the optimized test cases are analyzed for at least prioritization and further optimization of the optimized test cases for effective black box testing.

Abstract: A method and apparatus for detecting errors in an application software of an embedded system are provided. The method of detecting errors in an application software includes determining a development language of the application software and an operating system on which the application software is executed; replacing an error detection syntax inserted in order to examine an error in a predetermined function of the application software, with an error detection syntax according to the result of the determination; and performing exception handling for an error occurring in the function according to the result of the replacement, and logging error information according to the exception handling. According to the method and apparatus, an error can be automatically detected and logged irrespective of a development language and an operating system.

Abstract: In certain embodiments, execution traces for a program definition of an application are accessed. Probability information for components of the program definition is computed based at least in part upon the execution traces. Program definition slices are determined based at least in part upon the probability information. The program definition slices comprises a baseline slice and at least one supplemental slice. The baseline slice is communicated to a client in response to a request for the application. At least one supplemental slice is communicated to the client to allow the patching of the baseline slice with the at least one supplemental slice to recreate at least a portion of the program definition.

Abstract: A computer-implemented method for monitoring an object-oriented application is disclosed. A transaction-representative-digraph is built based upon a real-time running of the application, and the digraph contains nodes of a plurality of replaceable classes. A key node is selected based upon invocation relationships between the nodes. A monitor program is instrumented at the selected key node.

Abstract: An approach is provided to receive a request at a first computer system from a second system. The first system generates an encryption key, modifies retrieved source code by inserting the generated encryption key into the source code, and compiles the modified source code into an executable. A hash value of the executable program is calculated and is stored along with the encryption key in a memory area. The executable and the hash value are sent to the second system over a network. The executable is executed and it generates an encrypted result using the hash value and the embedded encryption key. The encrypted result is sent back to the first system where it is authenticated using the stored encryption key and hash value.

Abstract: A Design-Under-Test (DUT) may be designed to perform speculative execution of a branch path prior to determination whether the branch path is to be performed. Verification of the operation of DUT in respect to the speculative execution is disclosed. A template may be used to generate a plurality of tests. In addition to standard randomness of the tests to various parameters in accordance with the template, the tests may also differ in their respective speculative execution paths. The tests are partitioned by a generator into portions to be placed in speculative paths and portions to be placed in non-speculative paths. The generator may provide for a variance in portions. The generator may provide for nested speculative paths.

Abstract: Provided is an apparatus and method for automatically analyzing a program in order to detect window malicious codes that are programmed to perform malicious behaviors when a specific event occurs, when the specific event does not occur, when a specific program execution condition is satisfied, and when the specific program execution condition is not satisfied.