Abstract: A method for precisely counting guest branch instructions in a virtualized computer system is described. In one embodiment, guest instructions execute in a direct execution mode of the virtualized computer system. The direct execution mode operates at a first privilege level having a lower privilege than a second privilege level. A branch count of previously executed first privilege level branch instructions is maintained as instructions execute. Execution of a first privilege level branch instruction caused by a control transfer to the direct execution mode is detected. Responsive to the detection, a guest branch instruction count is determined based on the first privilege level branch count.

Abstract: An imperative framework having a more than one type is defined. At least one of the types is an immutable type, and the immutable type has at least one immutable field.

Abstract: A technique for identifying a minimum number of model elements associated with a model for generating a subset model of the model that includes receiving a model, a set of model elements and a set of dependency types associated with the model; assigning a collector component to each of the received model elements; locating a model element dependent on the received model element by one of the received dependency types; receiving from each collector a dependent model element, and for each dependent model element, determining whether the dependent model element has been collected by another collector with the same dependency type and updating a subset model list with the collected dependent model element to build a list of collected dependent model elements for generating a subset model in response to a negative determination.

Abstract: Instrumentation points are selected for an application by running the application with comprehensive instrumentation of its components in a development mode. The application can be run by a human operator and/or load simulator which provides requests to the application. The instrumented components are monitored as the application runs. A subset of the components is selected based on criteria such as an order in which the instrumented components are invoked, whether resource utilization, such as consumption of processor cycles, exceeds a threshold, or a frequency with which components are called or call other components, and only that subset is instrumented in a production mode of the application. In one approach, the subset includes components which are invoked when traffic to/from the application matches a pattern provided by an interaction model. As a result, relevant instrumentation points can be identified.

Abstract: A computing node is connected to a sensor and an actuator. The computing node receives a module which is used to program the computing node to perform a function associated with the sensor and the actuator.

Abstract: A method and system for validating translated files for inclusion in an application being developed. Translatable files having externalized content in a single base language are sent for translation into other languages. Translated files resulting from a translation of the translatable files are received. Each translated file is statically and dynamically validated to detect error(s). The static validation is based on comparing the translatable files to the translated files. The dynamic validation is based on a simulation of how a user interface of the application presents the externalized content, without including an actual presentation of the externalized content by the user interface. Modified translated files that correct the detected error(s) are received and provided for a presentation of the externalized content by the user interface.

Abstract: Updating code of a single processor in a multi-processor system includes halting transactions processed by a first processor in the system and processing of transactions by a second processor in the system are maintained. The first processor then receives new code and an operating system running on the first processor is terminated whereby all processes and threads being executed by the first processor are terminated. Execution of a self-reset of the first processor is commenced and interrupts associated with the first processor are disabled. Only those system resources exclusively associated with the first processor are reset, and memory transactions associated with the first processor are disabled. An image of the new code is copied into memory associated with the first processor, registers associated with the first processor are reset and the new code is booted by the first processor.

Abstract: A method and apparatus for configuring an element management system server (an EMS server) to support new network element service application versions without upgrading the EMS server software is provided. The EMS stores base version data that describes the data model of a first version of a service application installed on a network element. When a second version of the service application is available, incremental version data describing changes to the data model from the first version to the second version is obtained and stored. In response to receiving a client request involving a service application on a particular network element, the EMS may apply incremental version data, associated with the version of the service application installed on the particular network element, to the base version data to form merged version data that describes the data model of the version of the service application installed on the particular network element.

Abstract: A system and method for dynamically generating proxy classes in order to enforce call-by-value semantics between clients and EJBs collocated with a virtual machine. The virtual machine can be a Java virtual machine (JVM) or some other type of virtual machine. The proxy classes are dynamically generated at runtime using dynamic byte code generation. Generated proxies are then interposed between a client and an EJB. The interposition of the generated proxies allows the proxies to intercept communication between the client and the EJB. The dynamically generated wrapper classes may be used in any system wherein a first entity invokes a second entity, wherein the second entity has an interface that can be retrieved or introspected and utilizes call-by-value semantics.

Abstract: The exemplary embodiments provide a compiler for a reconfigurable integrated circuit having reconfigurable computational elements with a plurality of contexts. An exemplary compiler generates a compilation comprising a designation of a first type of reconfigurable computational element, the data input linkage or the data output linkage for a first action, and a portion of a first configuration for the first type of reconfigurable computational element comprising a first task identifier and the first action identifier. The reconfigurable integrated circuit utilizes the first task identifier and a run status designation in enabling and disabling corresponding contexts for execution by the reconfigurable computational elements. The first configuration, typically generated in a binding process, further comprises a first input data source address from the first data input linkage or a first output data destination address from the first data output linkage.

Abstract: A method and system for instrumentation are provided along with a method for instrumentation preparation. The method for instrumentation preparation may comprise obtaining address data of an original instruction in an original instruction stream, obtaining kernel mode data comprising a kernel breakpoint handler, obtaining user mode data comprising a user breakpoint handler, allocating a page of a process address space, creating a trampoline, associating the trampoline with a breakpoint instruction, and replacing the original instruction with the breakpoint instruction. The method for instrumentation may comprise detecting the breakpoint instruction, calling the kernel breakpoint handler, modifying an instruction pointer via the kernel breakpoint handler such that the instruction pointer points to the trampoline, and executing the trampoline.

Abstract: A software transactional memory system is described which utilizes decomposed software transactional memory instructions as well as runtime optimizations to achieve efficient performance. The decomposed instructions allow a compiler with knowledge of the instruction semantics to perform optimizations which would be unavailable on traditional software transactional memory systems. Additionally, high-level software transactional memory optimizations are performed such as code movement around procedure calls, addition of operations to provide strong atomicity, removal of unnecessary read-to-update upgrades, and removal of operations for newly-allocated objects. During execution, multi-use header words for objects are extended to provide for per-object housekeeping, as well as fast snapshots which illustrate changes to objects. Additionally, entries to software transactional memory logs are filtered using an associative table during execution, preventing needless writes to the logs.

Abstract: A computer-implemented method for memory access monitoring, implemented by a managed runtime environment computer system including a controller that monitors application behavior and determines actions to be taken to change a behavior of an application, and a runtime, dynamic compiler that analyzes the application and generates code sequences to access a memory access monitoring (MAM) mechanism, includes determining monitor information of a plurality of fields of a memory block to drive an optimization of the application.

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.

Abstract: A system and method are described for performing application loading and visualization. In one embodiment, an application is accessed on a client to be deployed on the server. The client is in communication with machines having resources corresponding to the application. The application is then deployed on the server, and the deployed application on the server references a copy of the resources that already resides on the server.

Abstract: An execution control method is described for use in a translator (19) which converts subject code (17) into target code (21). The translator (19) includes a translator trampoline function (191) which is called from a translator run loop (190) and which in turn calls either to a translator code generator (192) to generate target code, or else calls previously generated target code (212) for execution. Control then returns to the translator trampoline function (191) to make a new call, or returns to the translator run loop (190). Other aspects include making context switches through the trampoline function (191) and setting first and second calling conventions either side of the trampoline function (191). Jumping directly or indirectly between target code blocks (212) during execution is also described.

Abstract: Generating an instruction set for an architecture. A hierarchical description of an architecture is accessed. Groups in the hierarchical description that can be pre-encoded without increasing final width of said instruction set are pre-encoded. The hierarchical description is permutated into a plurality of variations. Each variation comprises a leaf-group and one or more sub-graphs to be encoded. For each said variation, the leaf-group and the one or more sub-graphs are encoded to produce a potential instruction set for each variation. One of the potential instruction sets is selected.

Abstract: An example embodiment disclosed is a method for reducing parallelism of computer source code. The method includes receiving multi-threaded program source code and representing the multi-threaded program source code as a polyhedral framework stored in computer readable memory. The polyhedral framework is used to convert the polyhedral framework from the multi-threaded program source code representation to a single-threaded program source code representation.

Abstract: A computer-implemented method of identifying software test cases to be executed is discussed. The method includes determining one or more features changed in a software project, correlating the one or more features with one or more secondary source code files that exhibit the one or more features, and identifying test cases to be executed based on the correlation between the one or more features and the one or more secondary source code files.

Abstract: Techniques for parsing electronic files are disclosed. In one particular exemplary embodiment, the techniques may be realized as an apparatus for parsing electronic files comprising an input module operable to read one or more electronic files, a syntax element store, associated with one or more syntax elements, a mutation module operable to mutate one or more of the one or more syntax elements and parse the one or more electronic files read from the input module, and an output module operable to create one or more normalized electronic files from the one or more parsed electronic files.