Abstract: Techniques generate memory-optimization logic for concurrent graph analysis. A computer analyzes domain-specific language logic that analyzes a graph having vertices and edges. The computer detects parallel execution regions that create thread locals. Each thread local is associated with a vertex or edge. For each parallel region, the computer calculates how much memory is needed to store one instance of each thread local. The computer generates instrumentation that determines how many threads are available and how many vertices and edges will create thread locals. The computer generates tuning logic that determines how much memory is originally needed for the parallel region based on how much memory is needed to store the one instance, how many threads are available, and graph size. The tuning logic detects a memory shortage based on the original amount of memory needed exceeding how much memory is available and accordingly adjusts the execution of the parallel region.

Abstract: Debugging capabilities for software running in a cloud-computing environment are disclosed. A controller identifies which machines in the cloud are running instances of software to be debugged. An agent is deployed onto the machines in the cloud to facilitate communication with the developer's machine. When the developer wants to debug software on the agent's machine, the agent downloads and installs a monitor onto the machine. The agent configures the machine for remote debugging via the monitor. A security mechanism ensures that only authenticated developers can access the monitor and the remote machine for debugging. A controller automatically determines which machines can be debugged, updates a list of processes available for debugging on the machines, and identifies how to connect a developer's debugging client to the machines. The controller permits remote debugging only upon request from an authenticated developer and only for those processes that the developer is permitted to debug.

Abstract: A computer-implemented method for creating a program for a multi-processor system comprising a plurality of interspersed processors and memories. A user may specify or create source code using a programming language. The source code specifies a plurality of tasks and communication of data among the plurality of tasks. However, the source code may not (and preferably is not required to) 1) explicitly specify which physical processor will execute each task and 2) explicitly specify which communication mechanism to use among the plurality of tasks. The method then creates machine language instructions based on the source code, wherein the machine language instructions are designed to execute on the plurality of processors. Creation of the machine language instructions comprises assigning tasks for execution on respective processors and selecting communication mechanisms between the processors based on location of the respective processors and required data communication to satisfy system requirements.

Abstract: Transaction data is received identifying characteristics of a particular transaction involving the first software component and a second software component as observed by an agent during operation of the system. The particular transaction is contemporaneous with another transaction involving software components in the system. It is determined, from the transaction data, that the particular transaction falls within a defined transaction boundary for the system and the other transaction falls outside the transaction boundary. A virtual service is instantiated for use in the particular transaction that simulates responses of a particular software component of the system.

Abstract: Aspects of the subject matter described herein relate to generating and caching software code. In aspects, a target device may receive software to install. The software may include source code that has not been compiled. The target device may install the software and indicate the source code of the package is to be compiled into intermediate or executable code that is persistently stored. If the target device receives a request to execute the software prior to it being compiled, the target device may compile and execute the software without delay. If the target device receives a request to execute the software after it is compiled, the target device may obtain and execute the compiled code. The behavior above may also be applied to scripting code obtained from a server remote to the target device.

Abstract: Apparatuses, methods, systems, and program products are disclosed for dynamically loading firmware based on workloads. A workload module determines a workload configured to be executed on a system. A firmware module determines a firmware configuration associated with the workload. A loading module dynamically accesses the firmware configuration associated with the workload from a remote data store, and loads the firmware configuration on the system prior to execution of the workload.

Abstract: A multi-display system for management of a software development project having a graphical user interface including interactive user interface elements representing one or more tasks in the software project, first and second source code databases, first and second object code databases, a migration module configured to migrate source code from the first source code database to the second source code database and migrate object code from the first object code database to the second object code database in response to a user input to the graphical user interface, a first output module for executing the one or more blocks of object code and displaying an output of the executed object code stored in the first object code database, a second output module for executing the one or more blocks of object code and displaying an output of the executed object code stored in the second object code database.

Abstract: In a method for executing software, a result produced from an execution of a copy of the software by a corresponding platform can be received from each of a plurality of platforms. A number of results of execution of the software can be determined. The extent to which the results match can be compared to a threshold. The matching results can be accepted as an agreed-upon output of the software when the extent to which the results match is equal to or greater than the threshold. The software can include an implementation of at least a portion of an act associated with an agreement between at least two entities.

Abstract: Methods, devices and systems are disclosed that interface a host computer to a specialized processor. In an embodiment, an instruction generation unit comprises attribute, decode, and instruction buffer stages. The attribute stage is configured to receive a host-program operation code and a virtual host-program operand from the host computer and to expand the virtual host-program operand into an operand descriptor. The decode stage is configured to receive the first operand descriptor and the host-program operation code, convert the host-program operation code to one or more decoded instructions for execution by the specialized processor, and allocate storage locations for use by the specialized processor. The instruction buffer stage is configured to receive the decoded instruction, place the one or more decoded instructions into one or more instruction queues, and issue decoded instructions from at least one of the one or more instruction queues for execution by the specialized processor.

Abstract: This application discloses a computing system configured to simulate an embedded system including a processor capable of executing embedded software, compile the embedded software into a format capable of execution by the computing system, insert instrumentation code into the compiled embedded software, and execute the compiled embedded software and the instrumentation code. The execution of the compiled embedded software can simulate execution of the embedded software by the processor in the simulated embedded system, while the execution of the instrumentation code can configure the computing system to gather information corresponding to the execution of the compiled embedded software.

Abstract: A virtual service is instantiated from a service model that is operable to receive requests intended for a particular software component in a system and generate simulated responses of the particular software component based on a service model modeling responses of the particular software component. A particular request intended for the particular software component is identified that has been redirected to the virtual service and content of a simulated response to the particular request is generated using the virtual service in a first language. A second language to be applied to the simulated response is determined based on the request, and a translation of the content from the first language into the second language is determined. A modified version of the simulated response is sent to the other software component in response to the particular request that includes the content in the second language.

Abstract: Techniques are disclosed for application configuration patching. Certain techniques are disclosed herein that utilize a configuration patching module (CPM) tool using a single workflow to perform application configuration patching. The CPM can receive a set of one or more binary patches for one or more applications a set of one or more binary patches for one or more applications, and a set of one or more patch metadata declarations for the one or more applications which correspond to at least one of the binary patches. A set of one or more actions can be identified from the set of patch metadata declarations. The CPM can generate a configuration patching execution plan including a set of one or more steps to be performed to implement the set of actions, and execute the set of steps of the configuration patching execution plan.

Abstract: A method includes analyzing, by a processor, a first version of a computer program. The analyzing includes identifying a first data processing element included in the first version of the computer program. The first data processing element references a first data source external to the first version of the computer program. The method includes generating a data source element that represents a second data source different from the first data source. The method includes generating a second version of the computer program. The second version of the computer program includes the generated data source element and a second data processing element that is based on the first data processing element. In the second version of the computer program, the second data processing element references the generated data source element.

Abstract: A method for upgrading vehicle electronic control units (ECUs) in a vehicle comprises: creating a differential upgrade package (DUP) for each upgrade to a predetermined ECU, said creating comprises: comparing a new image of the digital contents of a predetermined ECU flash memory with a present image of the digital contents of the predetermined ECU flash memory; and producing a set of changes to modify the present image to the new image, said changes comprising a set of instructions. The DUP comprises a set of instructions that are utilized to update the ECU flash memory a block at a time.

Abstract: A method for updating a test description for an automated computer test. The automated test is configured to cause a test computer system to communicate with a system under test comprising one or more computer programs being executed upon a computer device. The test description is configured to be executed by a test program to cause the test computer system to perform an automated computer test by comparing a received image from a GUI of the system under test with one or more reference images to identify an expected image. The method includes receiving a user input representative of the selection of a desired reference image from a GUI of a system under test.

Abstract: Systems, methods, and other embodiments are disclosed that are configured to verify the translation of a program from a first programming language to a second programming language. In one embodiment, a first program is executed within a first thread of a process in parallel with a second program within a second thread of the process. A first source code of the first program is written in the first programming language, and a second source code of the second program is a translation of the first source code of the first program to the second programming language based on a translation process. Statement flow and program variables are compared at equivalent lines of code between the first program and the second program, during execution of the two programs in parallel, to generate execution results. The translation process is transformed, based on the execution results, facilitating correcting of the second source code.

Abstract: Methods, systems, computer-readable media, and apparatuses for providing a scheme for managing Last-Modified information for resource requests are described herein. In some embodiments, a computing device may determine whether to round up or down an update time of a resource respectively based on whether a request from a client device for the resource is received within a window. In some embodiments, a computing device may receive, from a client device, a first validation request for a resource and a second validation request for the resource. In response to determining that the first validation request was received within a window, the computing device may round down an update time of the resource. In response to determining that the second validation request was received outside of the window, the computing device may determine whether to round up the update time of the resource.

Abstract: The present disclosure relates to a method and system for optimizing a test suite comprising plurality of test cases. In an embodiment, the pluralities of test cases are received from data sources. The method identifies one or more redundant and non-redundant test cases among the plurality of test cases in the test suite and computes similarity percentage between each of the non-redundant test cases by comparing test description and steps of each non-redundant test case with test description and steps of other non-redundant test cases. The non-redundant test cases are grouped into clusters based on the similarity percentage. Further, the method identifies test functions in each of the clusters for determining reusable test functions. Upon identifying the reusable test functions, test cases in each of the clusters are reconstructed by replacing each of the test cases with the reusable test function references thereby optimizing the test suite.

Abstract: An instrumentation analysis system processes data streams by executing instructions specified using a data stream language program. The data stream language allows users to specify a search condition using a find block for identifying the set of data streams processed by the data stream language program. The set of identified data streams may change dynamically. The data stream language allows users to group data streams into sets of data streams based on distinct values of one or more metadata attributes associated with the input data streams. The data stream language allows users to specify a threshold block for determining whether data values of input data streams are outside boundaries specified using low/high thresholds. The elements of the set of data streams input to the threshold block can dynamically change. The low/high threshold values can be specified as data streams and can dynamically change.

Abstract: The technology disclosed relates to systems and methods for using deduplication when rendering complex web pages with multiple iFrames, to improve performance and reduce memory requirements. We refer to the technology disclosed as “server-side rework” of interface web pages with multiple iFrames by post processing. Custom interface web pages with multiple iFrames can use the disclosed server-side rework to post-process complex interface web pages for improved performance and reduced memory requirements.