Abstract: Simplifying determination of whether application specific parameters are setup for optimal performance of associated applications. In an embodiment, a monitor program associated with an application specific parameter is identified and executed to cause retrieval of a current value of the parameter. The retrieved current value is then compared with a recommended value for the parameter to determine whether the parameter is setup for optimal performance of the application. The result of comparison may be displayed to the user. Another aspect provides for downloading of the recommended values and the monitor programs associated with application specific parameters from an external system (such as a vendor system). One more aspect enables the user to execute a correction program to correct the value of the parameter for optimal performance of the application.

Abstract: In a system in which documents are generated dynamically in response to user requests, historical data is collected regarding data retrieval subtasks, such as service requests, that are performed to generate such documents. This data is used to predict the specific subtasks that will be performed to respond to specific document requests, such that these subtasks may be initiated preemptively at or near the outset of the associated document generation task. A subtask that would ordinarily be postponed pending the outcome of a prior subtask can thereby be performed in parallel with the prior subtask, reducing document generation times. In one embodiment, the historical data is included within, or is used to generate, a mapping table that maps document generation tasks (which may correspond to specific URLs) to the data retrieval subtasks that are frequently performed within such tasks.

Abstract: A system and method for improving modularity of a software source code is provided. The system comprises of a user interface for receiving source code; a source code model extractor for parsing and forming a model of the source code; a source code model database for storing the source code model, refactoring operators, and a record of refactoring changes; a modularity improvement analyzer for reading the source code model and modularity problem diagnosis data and generating a set of prescriptions; an optimal improvement suggestion selector for evaluating and selecting prescriptions; and a refactoring engine for receiving selected prescriptions and applying them on the source code.

Abstract: Idle processor cores can be used to compile methods that are likely to be executed by a program based on profile data that is captured during one or more previous executions. Methods that are determined by the profile data to be likely to be used can be compiled eagerly on one or more background threads. Transparency can be achieved by ensuring that module load order is not altered because of the background threads by recording the state of loaded modules after each profiled compilation, persisting that data, and waiting to eagerly compile a method until the method to be compiled and all its dependencies has been loaded by the executing program.

Abstract: An information processing device includes an installation unit which downloads installation data of an application program corresponding to a function from an external device and installs the application program. A license acquisition unit acquires a license file from an external device in order to activate the function. A license managing unit manages presence of a license of the function independently of presence of the license file. A license transfer managing unit transfers the license from a source device to a destination device and updates the presence of the license of the function. An automatic return unit automatically returns the transferred license to the source device according to automatic return conditions stored in the information processing device.

Abstract: One embodiment of the present invention provides a system that inserts faults to test code paths. The system starts by placing fault-inserting method calls at join points within methods in program code. The system then executes the program code during a testing process. As a method is executed during the testing process, the system executes the corresponding fault-inserting method. This fault-inserting method checks a configuration database to determine whether a fault is to be simulated for the method and, if so, simulates a fault for the method.

Abstract: A probe management system identifies a probe module for an application, which includes a semaphore table that has entries for a plurality of probe points in the application. An entry includes a semaphore variable value for a probe point. The probe management system identifies one or more probe points that are to be activated from an introspection user script. The user script is for examining the execution of the application at one or more of the probe points in the application. The probe management system adjusts the semaphore variable values for the identified probe points in the semaphore table in the probe module to represent to the application that a probe point is to be activated and causes the application to activate the identified probe points based on the adjusted semaphore variable values in the semaphore table.

Abstract: A system described herein includes a receiver component that receives third party code for execution in a host environment, wherein the third party code corresponds to a dynamic programming language, and wherein the third party code has at least one object reference to a first object that is used by the third party code. A detouring component automatically replaces the first object referenced by the third party code with a proxy object such that the third party code at runtime calls the proxy object instead of the first object.

Abstract: A design tool hierarchically presents information about a design with nested blocks. For example, the design tool presents scheduling information for the design in a hierarchical Gantt chart. The scheduling information includes hierarchical design schedule blocks which accurately depict the timing and scheduling of the nested blocks of the design. Each of the hierarchical design schedule blocks includes control steps numbered relative to the block. The scheduling information also includes a hierarchical list of scheduled operations for the design. The hierarchical list emphasizes which operations are associated with which nested blocks. The scheduling information further includes pseudo-operation icons that are easily differentiated from real operation icons in the hierarchical Gantt chart.

Abstract: In general, in one aspect, the invention relates to a method for identifying program properties in source code. The method includes: identifying a set of program objects corresponding to a potential program property within the source code; identifying a function associated with the set of program objects in the source code; identifying an input and an output of the function in the source code; creating a value flow graph by: creating a function input node representing the input; creating a function output node representing the output; identifying value flow functions, where each value flow function defines a conditional dependency between a pair of graph nodes, and creating, based on the value flow functions, directed graph edges modeling a potential flow of data through the value flow graph; and identifying a feasible path in the value flow graph depicting an occurrence of the potential program property in the source code.

Abstract: Disclosed are embodiments a computer-implemented method, a system and an associated program storage device that provide for automatic programming language grammar partitioning to solve the “code too large” problem. The embodiments partition a particular programming language grammar into logical subsets based on a set of partitioning heuristics and using a dependency graph that is preprocessed so as to be devoid of any cyclically connected grammar rule nodes. For each logical subset, textual code for a corresponding portion of a parsing program can be generated and then converted into machine-readable code for that corresponding portion of the parsing program. Thus, small amounts of textual code for portions of a parsing program are discretely converted into machine-readable code, thereby avoiding the “code too large” problem. The machine-readable code for all portions of the parsing program can then be merged and the parsing program can be executed in order to parse a corpus.

Abstract: A data processing system is provided having a processor and analysing circuitry for identifying a SIMD instruction associated with a first SIMD instruction set and replacing it by a functionally-equivalent scalar representation and marking that functionally-equivalent scalar representation. The marked functionally-equivalent scalar representation is dynamically translated using translation circuitry upon execution of the program to generate one or more corresponding translated instructions corresponding to a instruction set architecture different from the first SIMD architecture corresponding to the identified SIMD instruction.

Abstract: The present disclosure includes a shader compiler system and method. In an embodiment, a shader compiler includes a decoder to translate an instruction having a vector representation to a unified instruction representation. The shader compiler also includes an encoder to translate an instruction having a unified instruction representation to a processor executable instruction.

Abstract: Technologies are provided herein for seamlessly updating firmware in a high availability enabled solution. A system for updating firmware in a high availability enabled solution includes a first active node that is functional on the system and which is connected to a firmware update client and a second passive node that is in an active-passive relationship with the first node. The first node receives a firmware update command and retrieves the updated firmware from the firmware update client. The first node then updates firmware of the second node using the updated firmware. Upon updating the firmware of the second node, the first node sets an indicator flag associated with the second node, which notifies the second node to become the active node upon being rebooted. The first node then reboots the second node, which then updates the firmware of the first node with the updated firmware.

Abstract: A software tool allows a user to filter out the results produced by a software source code correlation program that is executed on sets of software source code files. The tool allows the user to discard elements of source code that are not relevant to the analysis without requiring the user to run the correlation program multiple times.

Abstract: Modeling non-functional requirements (NFRs) in a computer programming environment. In one aspect, this further comprises: identifying use case (UC) artifacts having one or more NFRs; retrieving the one or more NFRs and any data associated therewith; analysing the associated data to define a test case therefor; retrieving a UC realization from a model to determine one or more possible program flows; and testing each possible program flow to select the test case which verifies the use case required, thereby modeling the NFR.

Abstract: Detecting locking discipline violations on shared resources. For example, a method of detecting locking discipline violations of shared resources of a computing platform, by a testing process to be executed concurrently with one or more other processes on said computing platform, the testing process comprising: locking a shared resource of said computing platform; reading a value of the shared resource; locally storing the value of the shared resource; rereading the value of the shared resource after a predefined time period; and generating a locking discipline violation report if the value of said shared resource as reread by said rereading is different from the value of said resource as locally stored by said locally storing.

Abstract: In one embodiment, analyze client-tier source code of a client-server software application to extract one or more software modules that handle user-input data of the software application. For each one of the software modules, extract from the software module one or more user-input constraints placed on the user-input data, comprising: analyze source code of the software module to determine one or more failure points in the source code; perform symbolic execution on the software module to extract one or more first expressions that cause the software module to reach the failure points, respectively; obtain a second expression as the disjunction of all the first expressions; obtain a third expression as the negation of the second expression; and extract the user-input constraints from the third expression. Determine one or more user-input data that satisfy all the user-input constraints.

Abstract: A method and system for providing a consistent flow documents and data content across different organizational units of a company or agency where the documents and data come from different enterprise systems and data stores but are related to linked processes that share models for organizing the content in the business context and in a format that enables a user to relate the content to the process step or steps they are performing. The system includes a network service that enables a configuration utility to automatically discover the objects and metadata and provides for a mapping of selected fields of the metadata to regions displayed in the user interface view with provision for filtering the data by mapping selected fields to a user input form. Thereby, a business analyst can create solutions without writing and maintaining complex program logic for each combination of presentation environment, enterprise system and data store.

Abstract: Systems and methods are described for capturing and utilizing specific module dependency information. A hierarchical model can be created to arrange the components an existing software system in a particular hierarchy. The model defines a priority of dependencies among the components. A tool is provided for analyzing each class file of the system for references to other class files and determining, for each said class file, whether each reference is acceptable according to the hierarchical model. Once the class files and references have been analyzed, a surrogate class file can be automatically generated for the references that are determined to be unacceptable according to the hierarchical model. This process can utilize white lists and black lists associated with the class files, where the white lists specify modules to which references are acceptable and the black lists specify modules to which references are unacceptable.