Abstract: Methods and systems are disclosed for performing dataflow execution by an accelerated processing unit (APU). Techniques disclosed include decoding information from one or more dataflow instructions. The decoded information is associated with dataflow execution of a computational task. Techniques disclosed further include configuring, based on the decoded information, dataflow circuitry, and, then, executing the dataflow execution of the computational task using the dataflow circuitry.

Abstract: Abstract interpretation based static analysis tools use relational/non-relational abstract domains to verify program properties. Precision and scalability of analysis vary basis usage of abstract domains. K-limited path-sensitive interval domain is an abstract domain that was conventionally proposed for analysis on industry strength programs. The domain maintains variables' intervals along a configurable K subsets of paths at each program point, which implicitly provides co-relation among variables. When the number of paths at the join point exceeds K, set of paths are partitioned into K subsets, arbitrarily, which results in loss of precision required to verify program properties. To address the above problem, embodiments of the present disclosure provide selective merging of paths in such a way that the intervals computed help verifying more properties.

Abstract: Provided are embodiments for a method of performing register pressure targeted function splitting. The method can include determining a candidate region of a function, the candidate region comprising variables, and determining a number of available registers in a computing system for allocating the variables of the function. The method can also include grouping the variables in the candidate region into first variables and second variables based at least in part on the number of available registers, and splitting the candidate region of the function into split functions based at least in part on the grouping of the variables. Also provided are embodiments for a computer program product and a system for performing register pressure targeted function splitting.

Abstract: Methods, computer program products, and/or systems are provided that perform the following operations: reading lines of code included in a collection of source code; identifying an assigned tag in the collection of source code; identifying a start tag location and an end tag location associated with the assigned tag, wherein the lines of code included between the start tag location and the end tag location identify a code block; processing the code block to generate logging data for the code block based, at least in part, on the assigned tag; and providing the logging data for linking to executable byte code compiled from the collection of source code, wherein the logging data is used to log code data relating to the code block during execution of the executable byte code.

Abstract: Disclosed are implementations for software debugging and application development, including a method that includes receiving an instrumentation request, associated with one or more contextual conditions, for application data resulting from execution of an application process on an application system, the application process corresponding to source code with a segment to capture data at a first observability level. The instrumentation request includes information to cause adjustment of the first observability level to a second observability level different from the first observability level.

Abstract: An apparatus to facilitate control flow in a graphics processing system is disclosed. The apparatus includes logic a plurality of execution units to execute single instruction, multiple data (SIMD) and flow control logic to detect a diverging control flow in a plurality of SIMD channels and reduce the execution of the control flow to a subset of the SIMD channels.

Abstract: One embodiment provides a system for automatic program repair (APR). The system identifies a first set of components under repair in a software system and determines, while executing an original test, second and third sets of components that are executed before and after, respectively, the first set of components. The system generates a first block of mock code that runs faster and simulates runtime behaviors of the second set of components, identifies a code region within the third set of components that affects a test result of the software system, and generates a second block of mock code that runs faster and affects the test result similarly. The system generates a fast-result test by replacing the second set of components with the first block of mock code and replacing the third set of components with the second block of mock code and performs APR by executing the fast-result test.

Abstract: Embodiments are directed to a system and methods for ingesting location event data and encoding location data in the event data to a proximity. The encoding includes geohashing latitude and longitude for each event to a proximity for analysis and throughput.

Abstract: A method, a computer program product, and a system for infrastructure discovery and service offering. The method includes discovering configuration information of components on an IT infrastructure of an enterprise. The method also includes discovering components, resources, and workload characteristics based on the configuration information. The method further includes analyzing the configuration information, components, resources, and workload characteristics to determine predictive need analytics and discovering applications operating within the IT infrastructure. The method also includes comparing the applications and predictive need analytics to cloud-based services to detect service compatibilities, and generating a decision-making chart based on the service compatibilities, wherein the decision-making chart indicates migratable components and applications in the IT infrastructure.

Abstract: Methods, devices and media for reducing register pressure in flexible vector processors are described. In various embodiments described herein, methods, devices and media are disclosed that selectively re-scalarize vector instructions in a sequence of instructions such that register pressure is reduced and thread level parallelism is increased. A compiler may be used to perform a first method to partially or fully scalarize vectorized instructions of a code region of high register pressure. A compiler may be used to perform a second method to fully scalarize a sequence of vectorized instructions while preserving associations of the scalar instructions with their original vectorized instructions; the scalar instructions may then be scheduled and selectively re-vectorized. Devices executing code compiled with either method are described, as are processor-readable media storing code compiled by either method.

Abstract: An approach is provided for implementing memory profiling aggregation. A hardware aggregator provides memory profiling aggregation by controlling the execution of a plurality of hardware profilers that monitor memory performance in a system. For each hardware profiler of the plurality of hardware profilers, a hardware counter value is compared to a threshold value. When a threshold value is satisfied, execution of a respective hardware profiler of the plurality of hardware profilers is initiated to monitor memory performance. Multiple hardware profilers of the plurality of hardware profilers may execute concurrently and each generate a result counter value. The result counter values generated by each hardware profiler of the plurality of hardware profilers are aggregated to generate an aggregate result counter value. The aggregate result counter value is stored in memory that is accessible by a software processes for use in optimizing memory-management policy decisions.

Abstract: Compaction of an ordered event stream (OES) is disclosed. An OES storage system can employing multiple tiers of storage devices, wherein the different tiers each can provide certain advantages and disadvantages that can be used to balance OES event storage costs, both monetarily and in terms of computing resource burden. Compaction can be facilitated by storing, in a stream map, a reference to an event stored via a second tier of storage in contrast to storing in the stream map actual events of a first tier of storage. A reference can be enabled by storing events in a chunk body and storing a location relationships in a header of the chunk. The stream map can then search headers for references, which can often be smaller than the events themselves, which references can then be communicated, stored, and updated in the stream map to facilitate OES compaction.

Abstract: Techniques are disclosed for determining the run-time performance of an application executing on a computing system with low impact on the performance of the computing system. For example, a time series telemetry data stream is obtained for each of a plurality of key performance indicators during run-time execution of the application on a computing system having a given system configuration. One or more statistical features are extracted from each time series telemetry data stream. Model parameters of a machine learning performance score model are populated with values of the extracted statistical features. A run-time performance score of the application is then determined using the model parameters of the machine learning performance score model populated with the values of the extracted statistical features.

Abstract: Embodiments described herein provide techniques enable a compute unit to continue processing operations when all dispatched threads are blocked. One embodiment provides for a method comprising executing multiple concurrent threads on a processing resource of a graphics processor, during execution, detecting that each of the multiple concurrent threads of the processing resource are blocked from execution, selecting a victim thread from the multiple concurrent threads, and suspending the victim thread. The thread state is stored to a thread scratch space in memory along with a blocking event associated with the victim thread.

Abstract: An automated application verification module is provided to identify one or more functions of a software application. There is added, for at least one of the identified functions, a verification prologue at the entry point of the function which does not alter the control flow of the original set of instructions of the function and/or does not change the semantics of the function when the verification prologue is executed in its entirety. There is added at least one corresponding verification prologue check to the software application, such that the verification prologue check is configured to automatically check the integrity of the corresponding verification prologue during execution of the software application.

Abstract: The disclosure concerns implementing, by a cryptographic circuit, a set of substitution operations of a cryptographic process involving a plurality of substitution tables. For each set of substitution operations of the cryptographic process, a series of sets of substitution operations are performed. One set of the series is a real set of substitution operations corresponding to the set of substitution operations of the cryptographic process. One or more other sets are dummy sets of substitution operations, each dummy set being based on a different permutation of said substitution tables.

Abstract: Apparatus and methods are disclosed for display-related analysis of call data in an IPBX. In an example embodiment, an apparatus is configured to route data/VoIP calls via a data-communications server. An interface circuit is configured to selected parameters of interest based on capabilities of a set of devices and generate subscription requests to subscribe the devices to the parameters of interest. A processing circuit is configured to generate call summary metrics from call event messages for calls routed by the server and with subscription requests being associated with the parameters of interest. The call summary metrics are evaluated in connection with the parameters of interest as subscribed to by the devices and results of the evaluation are provided to the communication devices.

Abstract: Embodiments allocate and synchronize virtual currency balance of a user among multiple user devices. A user profile is maintained at a central server. The user profile stores a total virtual currency balance and a designation of multiple user devices associated with the user. The total virtual currency balance may be divided among and allocated to the multiple user devices, for example, based on usage data associated with each user device. The portion of the total virtual currency balance allocated to each user device may be stored locally at a local wallet of the corresponding user device. The local virtual currency balance on a user device may be used to purchase goods or services, such as playing a game. If the locally stored virtual currency balance of a given user device runs low, the user device may request additional virtual currency from other user devices without contacting the central server.

Abstract: Methods and systems for backing up and restoring sets of electronic files using sets of pseudo-virtual disks are described. The sets of electronic files may be sourced from or be stored using one or more different data sources including one or more real machines and/or one or more virtual machines. A first snapshot of the sets of electronic files may be aggregated from the different data sources and stored using a first pseudo-virtual disk. A second snapshot of the sets of electronic files may be aggregated from the different data sources subsequent to the generation of the first pseudo-virtual disk and stored using the first pseudo-virtual disk or a second pseudo-virtual disk different from the first pseudo-virtual disk.

Abstract: Systems and methods for auto-tuning and compiling source code are provided. A first executable file is generated by compiling the source code in accordance with a first optimization scheme. Compiling reports, performance reports, and bottleneck information are generated for the first executable file. A second optimization scheme is generated, and a second executable file is generated by compiling the source code in accordance with the second optimization scheme. An optimized executable file is output based on the first executable file and the second executable file.

Abstract: A cryptographic circuit performs a substitution operation of a cryptographic algorithm. For each substitution operation of the cryptographic algorithm, a series of substitution operations are performed by the cryptographic circuit. One of the substitution operations of the series is a real substitution operation corresponding to the substitution operation of the cryptographic algorithm. One or more other substitution operations of the series are dummy substitution operations. A position of the real substitution operation in said series is selected randomly.

Abstract: This disclosure provides a solution for improving performance in a virtual machine. In this method, a platform independent intermediate representation of a code segment in an application is obtained from a first virtual machine which is operating on a first platform. The platform independent intermediate representation is generated through a run-time compilation by the first virtual machine. Native code is generated based on the platform independent intermediate representation, in which at least one piece of the native code corresponds to a second platform which is different from the first platform. The at least one piece of the native code is distributed to a second virtual machine which is operating on the second platform.

Abstract: Systems and methods for auto-tuning and compiling source code are provided. A first executable file is generated by compiling the source code in accordance with a first optimization scheme. Compiling reports, performance reports, and bottleneck information are generated for the first executable file. A second optimization scheme is generated, and a second executable file is generated by compiling the source code in accordance with the second optimization scheme. An optimized executable file is output based on the first executable file and the second executable file.

Abstract: The disclosed systems, apparatuses and methods are directed to optimizing by a compiler register resource allocation for functions of a module, using a Register File comprising a limited number of registers. After performing interprocedural analysis in the module, the compiler computes the number of registers used by each function, and compiles the function to final machine code, except at callsites where a call is detected to be made to another function. At each callsite and for each called function, the compiler expands call instructions to final machine code after computing and setting a relative index to be used by a called function for running in an available part of the Register File. The relative index optimizes register resource allocation by minimizing the number of spilled registers before a function is called.

Abstract: A method list is built for a currently executing application within a process virtual machine at a snapshot point, the method list comprising a set of methods capable of being executed by the currently executing application after the snapshot point, the snapshot point comprising an execution state of the currently executing application when a snapshot process is triggered. Profiling data of the currently executing application, collected prior to reaching the snapshot point, is committed, to a designated storage location. Using the profiling data and a just-in-time compiler of the process virtual machine, a method in the method list is compiled. Snapshot data comprising data of the execution state of the currently executing application at the snapshot point, including a result of the compiling, is stored.

Abstract: A computer device includes a memory. The computer device also includes at least one processor configured to execute a process and manage the memory for the process. The processor is further configured to execute one or more program instructions associated with an application, reach control flow transfer for the one or more program instructions, unwind a call stack associated with the one or more program instructions in response to a failure to meet a target control flow, identify an offending function call, and rewrite the offending function call. The rewritten function call includes a memory operation boundary check.

Abstract: A method, computer system, and computer program product for estimation of post-inlining transformation benefits are provided. The embodiment may include performing abstract interpretation on a program to find potential post-inlining transformations. The embodiment may also include encoding potential post-inlining transformations into a profitability metric by associating constraints under which a profit is determined to be realized. The embodiment may further include scaling the profitability metric using the relative execution frequency of the program point to which the transformation applies to favor applying transformations in the most frequently executed code paths. The embodiment may also include generating method summaries to store the potential post-inlining transformations in the method summaries. The embodiment may further include creating a method summary map to match each method with each method summary.

Abstract: Profile-guided optimization is a technique for optimizing execution of computer programs using profile information to improve program runtime performance. Obtaining the profile information can be challenging, especially in live production environments such as high-performance gaming systems. A profiling strategy is provided herein that obtains profile information without requiring extra effort from users. The profiling strategy collects several approximate, lightweight profiles called piecemeal profiles over one or more lifetimes of a computer program, or application. The piecemeal profiles are then used to generate whole program application profiles that can then be used to improve the execution of the application. A piecemeal profile is profile information of a section or portion of an application.

Abstract: A probabilistic framework for compiler optimization with multithread power-gating controls includes scheduling all thread fragments of a multithread computer code with the estimated execution time, logging all time stamps of events, and sorting and unifying the logged time stamps. Time slices are constructed using adjacent time stamps of each thread fragment. A power-gating time having a component turned off for each time slice is determined. Power-gateable windows that reduce energy consumption of the time slice is determined according to the power-gating time. The compiler inserts predicated power-gating instructions at locations corresponding to the selected power-gateable windows into the power-gateable computer code.

Abstract: A system and related method for building and deploying one or more inference models for use in remote condition monitoring of a first fleet of a first asset. The system includes model configuration data for subsequent use by a model builder application to construct one or more desired inference models for the first asset. The model configuration data is customized to the first asset and the desired one or more inference models, and is provided in a format which is easily readable and editable by a user of the system. The model configuration data is separate from the underlying processing algorithms which are employed by the model builder application in the constructing of the one or more desired inference models during a learning mode of operation of the system.

Abstract: An offload server includes: a parallel processing designation section configured to identify repeat statements in an application and specify a directive specifying application of parallel processing by an accelerator and perform compilation for each of the repeat statements; a parallel processing pattern creation section configured to create parallel processing patterns each of which specifies whether to perform parallel processing for repeat statements not causing a compilation error; a performance measurement section configured to compile the application with a parallel processing pattern, deploy the compiled application to a verification machine, and perform processing for a measurement of a performance of the application; and an executable file creation section configured to compile a parallel processing pattern with the highest processing performance to create an executable file.

Abstract: The invention discloses how even underdeveloped regions can be provided with telecommnunication terminals (mobile terminals, tablets, laptops) using little computing power of the telecommunication terminals, thus allowing a participation in the exchange of digital information.

Abstract: Data transformation in a distributed system of applications and data repositories is described. The subsystems for the overall framework are distributed, thereby allowing for customization to require only isolated changes to one or more subsystems. In one embodiment, a source code repository is used to receive and store source code. A build subsystem can retrieve source code from the source code repository and build it, using one or more criteria. By building the source code, the build subsystem can generate an artifact, which is executable code, such as a JAR or SQL file. Likewise, by building the source code, the build subsystem can generate one or more job specifications for executing the executable code. In one embodiment, the artifact and job specification may be used to launch an application server in a cluster. The application server can then receive data transformation instructions and execute the data transformation instructions.

Abstract: System and techniques for compressed integrity check counters in memory are described herein. A set of counters may be maintained for data areas in memory. A respective counter is the set of counters is used to provide a variance to encryption operations on a corresponding data area. The respective counter is each time data is modified in the corresponding data area. The respective counter implemented by a generalized multi-dimensional counter (GMDC). In response to a trigger, a counter reset is performed on the set of counters. The counter reset may include refreshing the corresponding data area using a new key and resetting the respective counter to a default value in response to the refresh.

Abstract: Embodiments of an informatics platform where collected data can be normalized, integrated and mapped to a knowledge source, such as medical vocabulary systems are disclosed. One example of such a knowledge source is Unified Medical Language System (UMLS) which is a knowledge source for biomedical applications. Embodiments as depicted herein may provided a method to convert the desired information from UMLS into an ontology representation to allow for its use in conjunction with an informatics system.

Abstract: A computing device having connectivity to a network stores one or more existing device models, where each of the one or more existing device models is a representation of a different client device used by a first authenticated user to access the network. The computing device obtains a device sample, which comprises network traffic data that is captured during a period of time and which is generated by a particular client device associated with the authenticated user of the network. The computing device determines, based on one or more relational criteria, whether the device sample should be assigned to one of the one or more existing device models or to an additional device model that has not yet been created. The computing device then determines relative identity of the particular client device based on whether the device sample is assigned to one of the one or more device models or to an additional device model that has not yet been created.

Abstract: A method, apparatus, and/or computer program product generates a predictive data structure for an application when operating offline in a network connected data processing system, the application comprising source code having an execution path. The method comprises: determining an exit point within the source code of the application; determining, from the exit point, an execution path comprising at least one conditional statement; identifying one or more branches of the at least one identified conditional statement and for each identified branch determining an expected response; for each determined expected response, generating a data structure from the response; continuing along the execution path of the source code from the exit point and replacing each request for a resource in the source code with a pointer to the generated data structure; and executing the source code with the pointer to the generated data structure from the determined exit point.

Abstract: Techniques are described for graph based code performance analysis of software, such as software that is being developed and tested in a development environment. Implementations provide a technique for instrumenting code by adding various annotations into the code. Each annotation may be a function call that executes with the annotated code, but does not alter the behavior and/or functionality of the annotated code apart from outputting call tracking information during execution. The call tracking information generated by annotations can be analyzed to generate a call graph that depicts calling relationships between functions in the code. The call graph can be presented within a user interface and/or automatically analyzed to develop recommendations regarding code coverage for testing, impact information describing how changes to one function impact another function, code optimization recommendations, and so forth.

Abstract: Described herein are technologies relating to including instrumentation code in enterprise pages and generating a report for an enterprise page based upon instrumentation data and organizational data. Instrumentation code in an enterprise page, when executed by a processor, causes the processor to generate instrumentation data, where the instrumentation data includes an identifier for the enterprise page and an identifier for a user who accessed the enterprise page. The instrumentation data is added to an instrumentation dataset. A report is generated for an enterprise page based upon the instrumentation data and organizational data, such that the report indicates how users across different sectors of the enterprise interact with the enterprise page.

Abstract: A system receives an incoming datastream at an incoming data rate or transmits an outgoing datastream at an outgoing data rate. The system may include a detection circuit to monitor the signal quality of the datastream. Responsive to changes in the monitored signal quality, the system may switch the data rate from a first data rate to a new data rate. If signal conditions are favorable, the system may switch to a higher data rate than the first data rate. If signal quality conditions worsen, the system may switch from the first data rate to a lower data rate to allow for a reduction in error rate.

Abstract: An apparatus to facilitate instruction scheduling is disclosed. The apparatus includes one or more processors to receive a block of instructions, divide the block of instructions into a plurality of sub-blocks based on a register pressure bounded by a predetermined threshold and instructions in each of the plurality of sub-blocks for processing.

Abstract: Examples disclosed herein relate to modifying a web page. In one example, in response to beginning execution of a process initiating generation of a web page of a web application at a server, a runtime agent is executed. In this example, the runtime agent modifies code of the web page to inject code to protect output of the web page. In the example, the process can be executed using the modified code to generate a modified web page.

Abstract: Methods and apparatus for reducing accelerator-memory access costs in platforms with multiple memory channels. The apparatus includes a computing platform having multiple accelerators and multiple memory devices accessed via a plurality of memory channels. Jobs are submitted via software running on the computing platform to access a function to be offloaded to an accelerator. Under the offloaded function, the accelerator accesses one or more buffers that collectively requiring access via multiple memory channels among the plurality of memory channels. Accelerators having an available instance of the function are identified, and an aggregate cost for accessing the one or more buffers via the multiple memory channels are calculated for each of the accelerators. The accelerator with the least aggregate cost is then selected to offload the function to. New Instruction Set Architecture (ISA) instructions are also disclosed to identify memory pages and memory channels used for buffers.

Abstract: Techniques for providing application contextual information. One or more sets of database context identifiers corresponding to events that occur within the database are generated by the database. The one or more sets of database context identifiers have at least one application context field. A session identifier corresponding to a session to be monitored is sent from the application to the database. Information to be stored in the database with the session identifier is sent to the database. Database logs and application logs are correlated using at least the session identifier.

Abstract: A method and system for energy savings with silent haptics is presented. A haptically-enabled device includes a processor that executes a haptic track containing haptic instructions. The haptic track is analyzed to determine the presence of a zero-force interval, also known as a silent haptic. The duration of the zero-force interval is determined, and if the duration exceeds a pre-determined threshold, then the system or method enters an energy savings mode. An overhead time associated with the terminating of the energy savings mode is determined. And, the energy savings mode is terminated at the conclusion of the zero-force interval less the overhead time.

Abstract: In one embodiment, a processor comprises: a first register to store a first bound value for a stack to be stored in a memory; a second register to store a second bound value for the stack; a checker logic to determine, prior to an exit point at a conclusion of a function to be executed on the processor, whether a value of a stack pointer is within a range between the first bound value and the second bound value; and a logic to prevent a return to a caller of the function if the stack pointer value is not within the range. Other embodiments are described and claimed.

Abstract: A system and method for generating remediated instructions that complies with one or more policies that specify constraints for computer executable instructions. The remediated instructions are generated based at least in part on an evaluation of a set of straight-line paths of the set of executable instructions and an execution flow for the set of straight-line paths.

Abstract: One or more client threads are executed. One or more processing threads corresponding to the one or more client threads are executed. The processing threads are configurable to generate statistical information for each database query statement processed by the corresponding client thread. The statistical information is generated from the processing threads. The statistical information is stored in chunks of memory managed via a plurality of queues. The chunks of memory containing the statistics are analyzed. Outlier statements are filtered based on the statistics. Non-outlier statements are stored by a storage device.

Abstract: A method for allocating registers in a compute unit of a vector processor includes determining a maximum number of registers that are to be used concurrently by a plurality of threads of a kernel at the compute unit. The method further includes setting a mode of register allocation at the compute unit based on a comparison of the determined maximum number of registers and a total number of physical registers implemented at the compute unit.

Abstract: A system and method for deploying user apps to user devices is disclosed. A service module on a host system maintains class files of the user app within an original archive, and creates an install agent archive and a modified user app archive from the original archive. In some embodiments, the service module deploys an install agent from the install agent archive and a runtime agent of the modified user app archive to the user device. In other embodiments, the install agent and the runtime agent are pre-installed within a virtual machine of the user device. The install agent receives the class files from the service module, and the runtime agent loads and executes the class files to deploy the user app on the user device. In a preferred embodiment, the system enables faster initial deployment and redeployment of user apps on Android user devices than current systems and methods.