Abstract: Cognitive analysis, including artificial intelligence, is implemented to dynamically determine service discovery and service binding. Specifically, cognitive analysis is used to determine a client's capabilities and based on the capabilities, a service version is selected and coupled/bound to the client. As a result of such loose coupling/binding with service signatures, service version upgrade at the client is not mandatory in the event of a server-side service version upgrade.

Abstract: In one embodiment, an illustrative method herein may comprise: listening, by an agent process, to a discovery-based execution of an application; determining, by the agent process, a plurality of transition locations during the discovery-based execution of the application; recording, by the agent process, the plurality of transition locations into a recorded file; and providing, by the agent process, the recorded file to cause injection of instrumentation into the plurality of transition locations during runtime of the application based on the recorded file.

Abstract: Systems, methods, and computer-readable media are disclosed for annotating configuration language function evaluation. One or more configuration language expressions may be received by a configuration language development environment. The one or more configuration language expressions may be parsed into one or more atomic configuration language expressions. Based on a particular route at the specified point of execution in an application, the one or more configuration language expressions may be evaluated. The annotations may be rendered to provide an explanation of an underlying control flow.

Abstract: Example methods disclosed herein to determine whether a first monitored device is compromised include determining a first entropy value for the first monitored device based on a first number of unique event identifiers included in log entries obtained for the first monitored device, the log entries associated with a first time window. Disclosed example methods also include determining a second entropy value for the first monitored device based on numbers of unique event identifiers included in corresponding groups of log entries obtained for respective ones of a plurality of monitored devices including the first monitored device, the groups of log entries associated with the first time window. Disclosed example methods further include determining whether the first monitored device is compromised based on the first entropy value and the second entropy value, and performing an action in response to a determination that the first monitored device is compromised.

Abstract: Source code of a graph analysis program expressed in a platform-independent language which supports linear algebra primitives is obtained. An executable version of the program is generated, which includes an invocation of a function of a parallel programming library optimized for a particular hardware platform. A result of executing the program is stored.

Abstract: A computer-implemented method and system involve providing a script-driven framework to monitor performance of operations on two or more sets of objects to be executed on a target system in parallel on separate threads according to a test scenario with user-defined language stipulations from a script file, and executing the script file through the framework to implement the test scenario on the target system. The language stipulations include an operation hierarchy for each of the two or more sets of objects and at least one synchronization point corresponding to a point in time at which operations on the separate threads are to be synchronized. The framework can be XML-compliant.

Abstract: A method for providing autofill suggestions in a development environment includes obtaining, from a user interface executing on a user device, a user input representing source code generated within a development environment. The source code created using a particular programming language and a programming code base. The method further includes determining, using a machine learning model, at least one autofill suggestion based on the user input, the autofill suggestion continuing the source code represented by the user input. The method further includes determining, using a rule-based semantic checker configured for the particular programming language, whether the autofill suggestion is semantically correct based on the development environment and the programming code base. The method also includes, when the autofill suggestion is semantically correct, transmitting the autofill suggestion for display on the user interface of the user device.

Abstract: An embedded device detection method, comprising the following steps: executing a task by an embedded device, wherein the task comprises multiple functions; when an abnormal interruption occurs to the task, obtaining a stack pointer and a program counter corresponding to the abnormal interruption by a detection device, wherein the program counter is configured to record a memory address in use when the abnormal interruption occurs to the task; obtaining a stack space corresponding to a first target function being executed according to the program counter when the abnormal interruption occurs to the task; finding out a second target function before the first target function is executed according to the stack pointer and the stack space; and correcting the task according to the second target function.

Abstract: A system and methods for efficiently injecting probes to executable code, which is then executed. Such probes may be used for example to examine the behavior of the code during execution. Optionally analyzing the behavior of the code during execution is used as part of a testing strategy for the code.

Abstract: A system and method of forming proxy server pools is provided. The method comprises several steps, such as requesting a pool to execute the user's request and retrieving an initial group. The system checks the service history of an initial group, including whether any of the proxy servers in an initial group are exclusive to existing pools. The exclusive proxy servers in an initial group with eligible proxy servers are replaced when needed and new proxy server pools are formed. The system also records the service history of proxy servers and pools before and after the pools are created. The method can also involve predicting the pool health in relation with the thresholds foreseen and replacing the proxy servers below the threshold.

Abstract: A method of selecting a last patch from among a plurality of patches for a same location according to an embodiment of this invention includes generating a plurality of patches for a same location in a program; calculating a final score based on a code change rate, a code complexity, and a context similarity for each of the plurality of patches.

Abstract: A method for executing new instructions includes the following steps: receiving an instruction and determining whether the received instruction is a new instruction. When the received instruction is the new instruction, entering a system management mode, and simulating the execution of the received instruction by executing at least one old instruction in the system management mode.

Abstract: An example method of reducing a container image size includes tracing an execution of a process running in a container. The container is associated with a first container image storing a set of files. The method also includes marking, based on the tracing, a subset of files accessed by the process. The method further includes creating a second container image storing the marked set of files.

Abstract: Improving developer efficiency and application quality, including: collecting, for an executing application, information describing the usage of the application; identifying one or more unencountered conditions that the application is configured to handle; identifying one or more encountered conditions that the application is not configured to handle; and presenting information describing the unencountered conditions that the application is configured to handle and the encountered conditions that the application is not configured to handle.

Abstract: A system and method are provided for testing application. The method is executed by a device having a communications module and includes initiating via the communications module, an application testing tool, to test an application build according to at least one metric and obtain a test result. The method also includes accessing via the communications module, session details generated by the application testing tool while testing the application build, to determine an overhead component introduced by the application testing tool in generating the test result. The method also includes adjusting the test result based on the overhead component to increase an accuracy of the test result.

Abstract: According to examples, an apparatus may include a processor and a memory on which are stored machine-readable instructions that when executed by the processor, may cause the processor to receive information regarding a performance characteristic of an application during predetermined time periods. The processor may calculate a rate of change in the performance characteristic over the predetermined time periods. Based on a determination that the performance characteristic of the application has changed over the predetermined time periods, the processor may tune values of a set of parameters for the application based on the calculated rate of change in the performance characteristic.

Abstract: Embodiments of the present disclosure relate to anti-tamper computer systems, in particular to methods and systems which can embed protection code into software. Among other things, the protection code helps prevent (and make it more costly) to reverse engineer to tamper with the protected software with malicious intent, such as, but not restricted to: the removal of a license protection mechanism; the removal of code displaying advertisements; the injection of a malicious thread into the program memory space; illicit usage; or any other kind of unauthorized modification of the software.

Abstract: One aspect provides a system for hardware-assisted pre-execution. During operation, the system determines a pre-execution code region comprising one or more instructions. The system increments a global counter upon initiating the one or more instructions. The system issues a first instruction, which involves setting, in a first entry for the first instruction in a data structure, a first prefetch region identifier with a current value of the global counter. Responsive to a head pointer of the data structure reaching the first entry, the system: determines, based on a non-zero value for the first prefetch region identifier, that the first entry is not available to be allocated; and advances the head pointer to a next entry in the data structure, which renders a load associated with the first entry as a non-blocking load. The system resets the global counter upon completing the one or more instructions.

Abstract: Distributed API accounting is disclosed, including: receiving from respective ones of a plurality of agents, a plurality of local counter values corresponding to an application programming interface (API) service counter identifier; logging the plurality of local counter values corresponding to the API service counter identifier; receiving a request for an aggregated counter value associated with the API service counter identifier; combining at least some of the logged plurality of local counter values associated with the API service counter identifier to determine the aggregated counter value corresponding to the API service counter identifier; and storing the aggregated counter value corresponding to the API service counter identifier.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for performing real-time code analysis. One of the methods includes receiving a request to perform real-time code analysis on source code, wherein the request identifies one or more target source code elements. A plurality of real-time annotation values occurring in the source code for the target source code elements are identified. A call graph is generated for the one or more target source code elements. The call graph is traversed to identify one or more real-time violations, wherein each real-time violation is an instance in the source code that violates one or more real-time safe criteria. An output is provided that identifies one or more of the real-time violations occurring in the source code.

Abstract: A system and method of forming proxy server pools is provided. The method comprises several steps, such as requesting a pool to execute the user's request and retrieving an initial group. The system checks the service history of an initial group, including whether any of the proxy servers in an initial group are exclusive to existing pools. The exclusive proxy servers in an initial group with eligible proxy servers are replaced when needed and new proxy server pools are formed. The system also records the service history of proxy servers and pools before and after the pools are created. The method can also involve predicting the pool health in relation with the thresholds foreseen and replacing the proxy servers below the threshold.

Abstract: A test apparatus for generating a test case based on a fault injection technique and a method of controlling the same are disclosed. The method includes identifying at least one function in a program to be tested based on a software detailed design, generating a test design document based on fault location that can be generated in connection with the identified at least one function and a fault type to be injected into the fault location, searching for the fault location to be injected based on the generated test design document and source code of the program, determining a fault injection scheme and the fault type, and predicting a result by applying a fault injection corresponding to the fault injection scheme and the fault type into the searched location to generate a test case.

Abstract: Systems and methods for version control of pipelined enterprise software are disclosed. Exemplary implementations may: store information for executable code of software applications that are installed and executable by users, receive first user input from a first user that represents selection by the first user of a first software pipeline for execution; receive second user input from a second user that represents a second selection by the second user of a second software pipeline for execution, wherein the second software pipeline includes different versions of software applications that are included in the first software pipeline; facilitate execution of the first software pipeline for the first user; and facilitate execution of the second software pipeline for the second user at the same time as the execution of the first software pipeline for the first user.

Abstract: A method includes receiving at a storage device a command from a host. When learning is active on the storage device, an initial parameter value of a plurality of parameter values is used for performing a first action of a plurality of actions for the command. The first action is performed using the initial parameter value of the plurality of parameter values for the command The first parameter value is incremented to a next parameter value of the plurality of parameter values for the command for use in reperforming the first action.

Abstract: A method in a mainframe computing system to invoke a partner product exit routine in an information management system while the information management system is in operation. The method includes scheduling an interrupt routine for execution, creating, by the interrupt routine, an information management system task, where the information management system task is a work unit that provides a logical service within the information management system, scheduling, by the interrupt routine, the information management system task for execution, invoking, by the information management system task, the partner product exit routine, and installing, by the partner product exit routine, a component of a software product that allows the software product to integrate with the information management system.

Abstract: A method for managing computing performance in a real-time data processing system, having at least one apparatus for controlling at least one computing device that is embodied for execution of a first and of at least one further application, at least the first application encompassing at least one anytime algorithm. The method includes: assigning a first computing-performance budget, as a function of a first point in time, to the first application; activating the computing device for execution of the first application, at the first point in time by the computing device; checking whether, after execution of the first application, a portion of the first computing-performance budget is still available and, in the event a portion of the budget is still available, performing (i) activating the computing device for re-execution of the first application, or (ii) assigning the portion of the first computing-performance budget to at least one further application.

Abstract: Methods and systems are disclosed for providing third party connectivity to installed software at a customer site through a broker infrastructure. A uniform facility for powerful and secure third party access to customer software installations is provided. Multiple TCP-based session types including source code debug and database sessions are supported. A target backend and session type are selected by an authorized agent logged into the broker infrastructure. A communication session is established between environments of the agent's frontend tool and the backend. The agent can perform maintenance or troubleshooting on the backend using the full capabilities of the frontend tool. Data exchange between frontend and backend utilizes TCP connections within the communication session, and is mediated by a connectivity framework within the broker infrastructure. Customer control over access to target backends is supported.

Abstract: Aspects include executing a first phase that includes injecting instrumentation into program code in response to identifying an inner conditional check in the program code and running the instrumented program with a representative workload. The injecting includes duplicating the inner conditional check and placing a duplicate of the inner conditional check before a respective original nested conditional check in the program code to create an instrumented program. The instrumented program includes a plurality of basic blocks including original basic blocks and a newly added basic block that includes the duplicate of the inner conditional check. The method also includes executing a second phase that includes collecting execution frequency values from counters associated with the basic blocks to form metadata used to make optimization decisions for the program code.

Abstract: At an interface an analytic model for processing data is received. The analytic model is inspected to determine a language, an action, an input type, and an output type. A virtualized execution environment is generated for an analytic engine that includes executable code to implement the analytic model for processing an input data stream.

Abstract: A system on chip (SOC) system includes functional modules, including a first and second functional module. The first and second functional module are configured to send, to an aggregation module and in a standardized message format, first and second status information associated with the first and second functional module according to a first and second set of one or more reporting rules, respectively. The aggregation module aggregates the first status information in the standardized message format and the second status information in the standardized message format and insert a timestamp to obtain a timestamped and aggregated message stream. The timestamped and aggregated message stream is stored and enables a visualization system to analyze the first functional module and the second functional module.

Abstract: Various embodiments of systems and methods to track tainting information via non-intrusive bytecode instrumentation are described herein. The described techniques include, at one aspect, defining a taint-aware class to shadow an original data class. The taint-aware class includes a payload field to store objects of the original data class, a metadata field to store tainting information corresponding to the objects of the original data class, and a method proxying a corresponding method of the original data class. In another aspect, the instances of the original data class are replaced with corresponding instances of the taint-aware class in an application bytecode. Further, in a yet another aspect, when executing the application in a runtime environment, the method propagates the content of the metadata filed and calls the corresponding method of the original data class to manage the content of the payload field.

Abstract: In one embodiment, a monitoring process modifies a class definition of an object of a monitored process to include an injected field. The monitoring process may then execute a first interception point of the monitored process, and sets, at the first interception point, the injected field to a given value. Upon executing a second interception point of the monitored process, the monitoring process can then read, at the second interception point, the given value in the injected field, and can use the given value at the second interception point for a corresponding correlation operation between the first interception point and the second interception point.

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 system and method for memory management. In one embodiment, the method includes generating a dependency structure comprising one or more task identifiers and one or more data object identifiers. The dependency structure includes a list of one or more dependencies for a first data object identifier of the one or more data object identifiers, a first dependency of the list identifying a first task for which a data object identified by the first data object identifier is an input. The method further includes counting the number of dependencies for the first data object identifier, decrementing the count by one when the first task completes execution, and, when the count reaches zero, deallocating the first data object.

Abstract: Disclosed is a test engine intended to evaluate the correctness and measure the performance effects of a binary transformation technique. The disclosed system takes source code as input and compiler information/flags as input. The transformation-under-test is applied to the compiler, creating a transformed compiler. A random test case generator residing within the test engine for injecting illegal code structures to modify the project source code, build flags, or compiler's operating environment, thereby creating an unlimited number of input test cases for the compiler. The test engine compiles the source code utilizing both the raw and transformed compilers and compares the results. For example, the test engine renders a pass/fail judgement on the binary transformation based on a metric of near equivalence between the results of the raw compiler and transformed compiler. By using one or more bitmasks, the evaluation process factors in differences attributed to compiler run-time generated artifacts.

Abstract: A system to facilitate data center security is described. The system includes a processor and a machine readable medium storing instructions that, when executed, cause the processor to receive a plurality of resources that are to be provided to process a workload, receive one or more characteristics associated with each of the plurality of resources, generate a resource signature for each of the plurality of resources using the one or more characteristics associated with each resource and generate an aggregated signature using the resource signatures generated for each of the plurality of resources.

Abstract: Hierarchical stalling strategies are disclosed. An indication is received of a stalling event caused by a requested resource being inaccessible. In response to receiving the indication of the stalling event, a set of cost functions usable to determine how to handle the stalling event is selected based at least in part on a type of the stalling event. The stalling event is handled based at least in part on an evaluation of the set of cost functions selected based at least in part on the type of the stalling event.

Abstract: Techniques are provided for application tracing for inline performance analysis.

Abstract: A system and method for application security profiling that includes extracting a code property graph from at least a subset of a code base; generating a code profile from the code property graph, wherein generating the code profile occurs prior to a compilation of the code base; and applying the code profile, comprising of identifying sections of interest within the code base.

Abstract: A method of checking for a stall condition in a processor is disclosed, the method including inserting an inline instruction sequence into a thread, the inline instruction sequence configured to read the result from a timing register during processing of a first instruction and store the result in a first general purpose register, wherein the timing register functions as a timer for the processor; and read the results from the timing register during processing of a second instruction and store the results in a second general purpose register, wherein the second instruction is the next consecutive instruction after the first instruction. The inline thread sequence may be inserted in sequence with the thread and further configured to compare the difference between the result in the first and second general purpose register to a programmable threshold.

Abstract: Methods and apparatuses are described for mutation testing of database functions. A computing device identifies database functions for testing from at least one database. The computing device generates, for each identified database function, mutated database functions by automatically applying mutations to the identified database function that change aspects of the identified database function. The computing device deploys the mutated database functions to the at least one database. The computing device determines line coverage attributes associated with each mutated database function. The computing device selects tests for execution against each mutated database function based upon the line coverage attributes associated with each mutated database function. The computing device executes the selected tests against each mutated database function using test automation applications to determine an outcome associated with each test.

Abstract: Operations include a compilation process and a runtime process. A compiler compiles code to generate virtual machine instructions. The compiler further generates information referencing respective parameter types of the parameters of a target virtual machine instruction. The compiler stores the information external to and in association with the target virtual machine instruction. The information may be included in another virtual machine instruction that precedes the target virtual machine instruction. A runtime environment processes the target virtual machine instruction based on the information stored external to and in association with the target virtual machine instruction. Parameter types referenced by the external information override parameter types that are (a) referenced by the target virtual machine instruction itself, (b) deduced by the runtime environment and/or (c) stored directly in association with the parameter values.

Abstract: A computer device processes frame data provided by running of a computer app, the frame data comprising a plurality of events occurring in the computer ap. A display displays information associated with one or more frames of the plurality of frames. At least one processor of the computer device determines a node graph, in response to input from a user, for one or more events associated with one or more frames from the frame data and that node graph is displayed.

Abstract: A kernel-based proactive engine can be configured to evaluate system call functions that are invoked when user-mode objects make system calls. As part of evaluating a system call function, the kernel-based proactive engine can generate a feature vector for the system call function. The kernel-based proactive engine can then analyze the feature vector using a multidimensional anomaly detection algorithm that has been trained using feature vectors of system call functions that are known to be safe. When the evaluation indicates that the feature vector is anomalous, the kernel-based proactive engine can block the system call.

Abstract: In one embodiment, a method includes accessing a current-visitor context of a current visitor to a web page in a current web-browsing session. The current-visitor context includes one or more data associated with or concerning the current visitor. The method includes selecting based on the current-visitor context a particular one of multiple possible instances of the web page for presentation to the current visitor. The particular one of the multiple possible instances of the web page is substantially most likely to generate a highest expected outcome from interaction with the web page by the current visitor as indicated by the current-visitor context.

Abstract: In an embodiment, a compiler for generating command bundles is configured to receive an execution definition that includes operations for execution. The compiler determines an ordered set of hardware functions corresponding to a hardware architecture to execute at least one operation. The hardware architecture may be selected from typical processor types or a command-aware hardware processor. The compiler generates a command bundle that includes a set of logically independent commands based on hardware functions and functionality of the hardware architecture to optimize execution of the operations. A command-aware hardware processor includes a hardware routing mesh that includes sets of routing nodes that form one or more hardware pipelines. Many hardware pipelines may be included in the hardware routing mesh. A command bundle is transmitted through a selected hardware pipeline via a control path, and is modified by the routing nodes based on execution of commands to achieve a desired outcome.

Abstract: A system and method for sampling application programming interface (API) execution traces in a computer system uses feature vectors of the API execution traces that are generated using trace-context information. The feature vectors are then used to group the API execution traces into clusters. For the cluster, sampling rates are generated so that a sampling rate is assigned to each of the clusters. The sampling rates are then applied to the API execution traces to adaptively sample the API execution traces based on the clusters to which the API execution traces belong.

Abstract: A method of rendering a service graph responsive to a query comprises generating a plurality of frontend traces and a plurality of backend traces associated with an application or website. The method also comprises determining connection information between one or more frontend traces of the plurality of frontend traces and corresponding backend traces of the plurality of backend traces. Further, the method comprises consolidating the one or more frontend traces with the corresponding backend traces to form one or more end-to-end traces using the connection information. Responsive to the query, the method comprises retrieving a set of exemplary end-to-end traces from the one or more end-to-end traces and rendering a service graph in accordance with constraints applied in the query using the set of exemplary end-to-end traces and the connection information.

Abstract: An improved system and method for characterizing application performance are disclosed. The system may comprise a profiling module and a web service module. The profiling module may be configured to prompt the user to select a public mode or a private mode and specify software and hardware targets for profiling. Test results from profiling may be combined with historical data obtained from a web service module providing access to a database of historical profiling test results to create recommendations for improving performance. The profiling module may upload the test-generated data in public mode to the web service module for use in future execution cycles or keep them private if in private mode.

Abstract: A tracing controller may utilize a binary execution trace mechanism to trace execution of compiled application machine code. The tracing controller may initiate hardware tracing to gather control-flow hardware traces of a method executing on a processor configured to generate hardware tracing information. The controller may generate a profile based on the hardware tracing information and initiate re-compiling or re-optimizing of the method in response to determining that the new profile differs from the previous profile. The controller may repeatedly profile and re-optimize a method until profiles for the method stabilize. Profiling and hardware tracing of an application may be selectively enabled or disabled allowing the controller to respond to later phase changes in application execution by re-optimizing, thereby potentially improving overall application performance.