Abstract: The disclosure invention provides a method for executing a program compiled for a source architecture on a machine having a different target architecture, a non-transitory computer readable medium configured to store instructions for performing such a method, and a system for performing such a method.

Abstract: Computerized robotic process automation (RPA) methods and systems that increase the flexibility and lower the cost with which RPA systems may be deployed are disclosed herein. In one embodiment, an RPA system and method avoids the need for preinstalled RPA software on a device employed by a user to create and/or execute software robots to perform RPA. In another embodiment, an RPA system and method provides a capability to execute software robots that may have been encoded in one or more programming languages to execute on an operating system different than that employed by a server of the RPA system.

Abstract: A conversion system includes a build manager, a file storage device to store original files associated with computer code or data of a project build, a compiler, a cache to store converted files, and an interceptor to provide requested files to the compiler. The interceptor includes one or more processors and memory storing instructions that cause the processor(s) to receive a plurality of file requests for files from the compiler during compilation between a starting and an ending of at least a portion of the project build, examine the cache to determine whether a requested file is stored in the cache for each of the file requests received between the starting and ending of the portion of the project build, and provide the requested file to the compiler.

Abstract: The disclosure herein describes platform-level migration for deep learning training (DLT) jobs from a checkpointed stated between a source node and a destination node. The checkpointing is performed through capturing GPU state (e.g., device state) and CPU state (e.g., host state). The GPU state includes GPU data (e.g., model parameters, optimizer state, etc.) that is located in the GPU and GPU context (e.g., the default stream in GPU, various handles created by libraries). Restoring the DLT job on the destination node involves resumption of processing of a destination GPU at the same checkpointed state.

Abstract: Techniques and architectures for representing data with one or more n-dimensional representations and/or using one or more models to identify malware are described herein. For example, the techniques and architectures may determine one or more coordinates for one or more points based on one or more sets of bits in the data and generate an n-dimensional representation for the data based on the one or more points. The techniques and architectures may evaluate the n-dimensional representation with one or more machine-trained models to detect malware.

Abstract: Described techniques enable inter-environment communication, including isolating two runtime environments from one another as needed to ensure that operations of one runtime environment do not negatively affect operations of the other runtime environment during the inter-environment communication. Such isolation may be maintained when the two runtime environments use different addressing schemes, and when the two runtime environments use different call linkage techniques for identifying, locating, and passing stored parameters or other data.

Abstract: Systems and methods for IC chip design testing can include a hardware emulator, having circuitry to emulate functionalities of an integrated circuit chip design and a buffer, detecting an assertion failure event indicative of a failed assertion on one of the functionalities, and storing a message indicative of the assertion failure event in the buffer. The circuitry can transfer, asynchronously relative to execution of the hardware emulator, the message from the buffer to a software host device without halting the execution of the hardware emulator. The software host device can receive the message indicative of the assertion failure event, and execute, asynchronously relative to the execution of the hardware emulator, at least one fail action instruction associated with the assertion failure event.

Abstract: A dynamic library replacement technique enables replacement of original functions or methods of application libraries based on analysis of traces captured by a client library of an investigative platform. Traces captured from the user application are analyzed to identify the original methods of the user application that may be replaced by the client library. The original methods may be identified based on estimated performance improvements determined from the analysis of the captured traces. The improved method replacements and estimated performance improvements may be graphically presented to a user via a user interface (UI) infrastructure of the investigative platform. Replacement of the improved methods may be defined in the dynamic configuration or interactively via the UI infrastructure and continued performance monitoring reported. The specific performance for any method may be monitored along with a fidelity of the monitored method.

Abstract: A wrapping method and device, a registration method and device, and a rendering apparatus are provided, which are related to a field of computer display technology. The specific implementation includes: receiving a creation instruction from a registry component, wherein the creation instruction includes an identification of a wrapper object to be registered, in a target code; and creating a corresponding wrapper object in the wrapper module, according to the identification of the wrapper object to be registered in the target code. In embodiments of the present application, a wrapper object may be quickly created in a wrapper module according to an identification of a wrapper object to be registered in a target code, which is beneficial to a reuse of a wrapper object, thereby improving code execution efficiency.

Abstract: A non-transitory computer-readable recording medium having stored therein a program for causing a computer to execute a process. The process includes storing each of a plurality of generation instructions in a storage area for each of assembly instructions, the generation instructions instructing the generation of instruction sequences of a first instruction set, each instruction sequence of the first instruction set executing a processing equivalent to each assembly instruction of a second instruction set, identifying a first register that is not used by any of the assembly instructions corresponding to the plurality of generation instructions by referring to the storage area, determining a second register of the first instruction set corresponding to the first register as a temporary register in each of the instruction sequences, and generating the instruction sequence that uses the temporary register.

Abstract: Disclosed herein are system, method, and computer program product embodiments for enhancing parameter-less exit-calls from a command line interface (CLI). An embodiment operates by obtaining a parameter and a name for a task script, and then generating a shell script including the name of the task script and an instruction to execute the task script based on the parameter. Then, an execution request for a task including an exit-call is sent to the CLI. The execution request includes a name of the shell script for the exit-call. The CLI calls the shell script in response to the exit-call during execution of the task. Further, the task script is executed based on the parameter in response to the CLI calling the shell script.

Abstract: Unused instructions and no longer used instructions in a target application binary are determined. The target application binary is rewritten before and after runtime execution of the target application binary to remove the unused and no longer used instructions to reduce binary attack surface area for the runtime execution of the target application binary. Methods, computer systems, and computer program products are disclosed.

Abstract: Various embodiments of exchanges are described. Methods and other embodiments are also described.

Abstract: Aspects of the disclosure relate to machine learning based test coverage in a production environment. A computing platform may retrieve, for a software application, first log data associated with a production environment, and generate a production navigational graph where a node represents a webpage visited by a user, and an edge represents a navigational link between two webpages. Likewise, second log data associated with a testing environment may be retrieved, and a testing navigational graph may be generated, where a node represents a webpage tested by a developer, and an edge represents a navigational link between two webpages. Then, the computing platform may generate a coverage graph indicative of a gap between the navigation activity and the testing activity. Subsequently, the computing platform may provide, via an interactive graphical user interface, the coverage graph, where nodes and edges of the coverage graph are associated with selectable visual objects.

Abstract: A method for migration of a virtual network function, VNF, from a source node to a destination node includes receiving by the destination node a snapshot of a state of the virtual network function implemented by the source node and receiving by the destination node state update elements encoding a change of the state of the virtual network function implemented by the source node caused by processing of one or more data packets received by the source node since the snapshot.

Abstract: Systems, apparatus and methods described herein are configured to receive a user command line instruction, of a first type, for transmission to a device and convert the user command line instruction to a device specific command line instruction. In some embodiments, the systems, apparatus and methods described herein are further configured to transmit the device specific command line instruction to the device, and convert a device specific response received from the device to a response of the first type.

Abstract: A system, computer program product, and method are provided for supporting risk evaluation and modification of an executable codified infrastructure. The codified infrastructure is analyzed to identify any non-native program instructions. A selection of the identified non-native program instructions are combined and subjected to a risk evaluation by non-native tools. A risk evaluation result is mapped to corresponding lines of the source code, and a risk identifier is assigned to the corresponding lines of the source code. One or more modifications are selectively applied to the codified infrastructure in correspondence with the assigned risk identifier. The applied modification mitigates any defects in the source code.

Abstract: An information providing method of an electronic apparatus is disclosed. The information providing method may include receiving a counter information request, identifying cache counter information corresponding to the counter information request from a cache database related to a counter, and transmitting response information corresponding to the counter information request based on the identified cache counter information.

Abstract: According to one example, a method includes determining that a first virtual machine on a source node is to be migrated, selecting a first plurality of destination nodes for the first virtual machine, and simultaneously migrating the first virtual machine to each of the first plurality of destination nodes. The method further includes, after the migrating has started and before the migrating has finished, selecting one of the first plurality of destination nodes as a designated node. The method further includes discontinuing the migrating to each of the first plurality of destination nodes except the designated node.

Abstract: The present invention relates to a security processing unit of PLC and a bus arbitration method thereof, to provide PLC with an active defense means to build a PLC hardware and software security layer. On a hardware security layer, a part of hardware processing mechanism is added to support trusted measurement, encryption algorithms and signature algorithms, and a virtual isolation technology is used; and on a software security layer, transparent encryption and decryption, integrity verification, backup recovery and virtual isolation security mechanism are provided. The security processing aspect is improved to achieve the purpose of security and reliability. The present invention can correctly establish a trusted environment of PLC to ensure that PLC is guided by a strictly verified path. A new star type trusted structure is designed to reduce loss during information transmission and increase information transmission efficiency.

Abstract: An example method facilitates associating data objects with elements of a process to be implemented via a process-based software application. The example method includes determining that a developer has added a particular software element to a software application being developed by the developer; accessing metadata describing the software element; and using the metadata to automatically associate the software element to one or more data objects to be used by the software element during running of the software application. A process cloud may facilitate implementing the method by automatically performing data mapping for software elements, such as approval tasks, forms, and so on, by determining appropriate task outcome data objects with reference to data characterizing a software flow of the software application, and by similarly automatically selecting and/or creating data objects for forms, which may be associated with or used by a task.

Abstract: Systems, computer-implemented methods, and computer program products that facilitate identifying computer software vulnerabilities, and more specifically, execute an approximate representation of software to produce a fingerprint are provided. In one example, a system is provided. The system can comprise a memory that stores computer executable components and a processor that executes the computer executable components stored in the memory. The computer executable components can include a filter component and an execution component. The filter component can filter a platform-independent intermediate representation to a filtered representation. The execution component can execute the filtered representation on a virtual machine to produce an output vector which can be used to identify computer software vulnerabilities.

Abstract: Methods, systems, and computer-readable media for transforming validated user interface layouts using inter-platform design mapping data are presented. A computing device may load source mockup data defining a first validated user interface layout associated with a first set of user interface design guidelines. Subsequently, the computing device may load interface mapping data defining relationships between first user interface elements associated with the first set of user interface design guidelines and second user interface elements associated with a second set of user interface design guidelines different from the first set of user interface design guidelines. Then, the computing device may transform the source mockup data based on the interface mapping data to produce target mockup data defining a second validated user interface layout associated with the second set of user interface design guidelines.

Abstract: A method of providing by a code optimization service an optimized version of a code unit to a managed runtime environment is disclosed. Information related to one or more runtime conditions associated with the managed runtime environment that is executing in a different process than that of the code optimization service is obtained, wherein the one or more runtime conditions are subject to change during the execution of the code unit. The optimized version of the code unit and a corresponding set of one or more speculative assumptions are provided to the managed runtime environment, wherein the optimized version of the code unit produces the same logical results as the code unit unless at least one of the set of one or more speculative assumptions is not true, wherein the set of one or more speculative assumptions are based on the information related to the one or more runtime conditions.

Abstract: A compiler translates programs for execution on a quantum processing system. To facilitate portability of quantum programs across differently configured quantum processors, the compiler accepts a specification of the quantum processor as input along with a quantum program for compilation. A specification may include information about the type of each qubit device in the quantum processor, the number of qubits, the qubit topology, coherence times of individual qubits, and operations that the quantum processor supports. The compilation process may include manipulating operations of the input program to generate equivalent operations that can be performed by the quantum gates and qubit devices on the quantum processor for which the program is being compiled.

Abstract: The specification provides example service processing methods and devices. One example method includes detecting a device type of an electronic device. An instruction processing rule corresponding to the device type is obtained. The instruction processing rule includes an instruction set conversion rule defining a process for converting display modification instructions generated by the electronic device into unified display modification instructions. A first display modification instruction initiated in response to a user interacting with the electronic device is obtained based on the instruction processing rule. The first display modification instruction is converted into a corresponding first unified display modification instruction according to the instruction processing rule. A portion of interaction data output to a display us updated by invoking a service processing mode corresponding to the first unified display modification instruction.

Abstract: Techniques and architectures for representing data with one or more n-dimensional representations and/or using one or more models to identify threats associated with the one or more n-dimensional representations are described herein. For example, the techniques and architectures may determine one or more coordinates for one or more points based on one or more sets of bits in the data and generate an n-dimensional representation for the data based on the one or more points. The techniques and architectures may evaluate the n-dimensional representation with one or more machine-trained models to detect a threat associated with the data, such as malware or another threat.

Abstract: Systems, computer-implemented methods, and computer program products to facilitate quantum domain computation of classical domain specifications are provided. According to an embodiment, a system can comprise a memory that stores computer executable components and a processor that executes the computer executable components stored in the memory. The computer executable components can comprise an input transformation component that can be adapted to receive one or more types of domain-specific input data corresponding to at least one of a plurality of domains. The input transformation component can transform the one or more types of domain-specific input data to quantum-based input data. The computer executable components can further comprise a circuit generator component that, based on the quantum-based input data, can generate a quantum circuit.

Abstract: The disclosure invention provides a method for executing a program compiled for a source architecture on a machine having a different target architecture, a non-transitory computer readable medium configured to store instructions for performing such a method, and a system for performing such a method.

Abstract: On a computer system having a processor, a single OS and a first instance of a system driver installed and performing system services, method for sharing driver pages among Containers, including instantiating a plurality of Containers that virtualize the OS, wherein the first instance is loaded from an image, and instantiating a second instance of the system driver upon request from Container for system services by: allocating virtual memory pages for the second instance and loading, from the image, the second instance into a physical memory; acquiring virtual addresses of identical pages of the first instance compared to the second instance; mapping the virtual addresses of the identical pages of the second instance to physical pages to which virtual addresses of the corresponding pages of the first instance are mapped, and protecting the physical pages from modification; and releasing physical memory occupied by the identical pages of the second instance.

Abstract: A method, apparatus and product for GUI element acquisition using a plurality of alternative representations of the GUI element. The method comprising: obtaining a selection of a Graphical User Interface (GUI) element; obtaining a representation set of the GUI element, wherein the representation set comprises a plurality of alternative representations, each of which provides a manner of identifying the GUI element in GUIs; applying the representation set to identify the GUI element in a GUI of a program, wherein said applying the representation set comprises, for each representation of the alternative representations, independently applying the each representation to identify one or more GUI elements corresponding the each representation; and in response to determining that said applying the representation set provides an indefinite result, obtaining a modified representation set.

Abstract: Methods, systems, and computer-readable media for a development environment for programming quantum computing resources are disclosed. A development environment receives information associated with a quantum algorithm. A quantum computing resource is selected for implementation of the quantum algorithm based at least in part on one or more metrics analyzed by the development environment. The quantum computing resource comprises a plurality of quantum bits and is selected from a pool of computing resources of a provider network. A program executable on the quantum computing resource is generated based at least in part on the information associated with the quantum algorithm.

Abstract: Disclosed are systems and methods for execution of program code by an interpreter. One exemplary method comprises: generating intermediate instructions based on a unified grammar from instructions of the program code, beginning execution of the intermediate instructions in an emulated computer environment, in response to detecting an instruction of the program code associated with an object for which a rule of interpretation is not found, halting further execution of the intermediate instructions, obtaining an auxiliary code corresponding to the object, wherein a result of execution of the auxiliary code corresponds to the result of the execution of the object, and wherein the auxiliary code contains objects for which the interpreter has a rule of interpretation, executing the instructions of the auxiliary code; and after completion of the execution of the auxiliary code, resuming the execution of the intermediate instructions.

Abstract: Some examples described herein relate to dynamically applying a patch to a computer application. An external process may be invoked to bring a target process of the computer application to a safe point. A dynamic loader may load a patch library into an address space of the target process, wherein the patch library includes a patched version of a target function or a new function. A specific function in the dynamic loader may be directed to route a function call for the target function to the patched version of the target function or the new function in the patch library.

Abstract: According to one aspect, a distributed database system is configured to manage multi-writer operations on a distributed database by implementing one or more catamorphic database operators. Catamorphic operators can be architected on the system, and executed with little or no reconciliation logic. Catamorphic operators define sets of catamorphic operations and respective execution logic where the order of execution of catamorphic operations is not relevant to a final result.

Abstract: Methods, apparatus, systems and articles of manufacture to perform region formation for usage by a dynamic binary translation are disclosed. An example apparatus includes an initial region former to form an initial region starting at a first block of hot code of a control flow graph. The initial region former also adds blocks of hot code lying on a first hottest path of the control flow graph. A region extender extends the initial region to form an extended region including the initial region. The extended region begins at a hottest exit of the initial region and includes blocks of hot code lying on a second hottest path until one of a threshold path length has been satisfied or a back edge of the control flow graph is added to the extended region. A region pruner prunes the remove all loop nests except a selected loop nest which forms a final region.

Abstract: In one embodiment, Quality of Service (QoS) criteria based server side binary translation and execution of applications is performed on multiple servers utilizing distributed translation and execution in either a virtualized or native execution environment. The translated applications are executed to generate output display data, the output display data is encoded in a media format suitable for video streaming, and the video stream is delivered over a network to a client device. In one embodiment, one or more graphics processors assist the central processors of the servers by accelerating the rendering of the application output, and a media encoder encodes the application output into a media format.

Abstract: A machine monitoring method preferably includes receiving packets, such as packets supplied to a physical machine, virtually simulating physical machine operation, and analyzing the virtual outputs of the virtual simulation. Virtually simulating physical machine operation is preferably performed based on the received packets, such as using a digital duplicate of the physical machine. Analyzing the virtual outputs can include, for example, determining simulated states of one or more aspects, such as physical components, of the physical machine, and/or determining that one or more events associated with physical machine operation have occurred. The method can optionally include, for example, transmitting the analysis results to a remote device, determining the digital duplicate of the physical machine, determining an analysis model for the virtual outputs of the digital duplicate, determining digital component modules, and/or determining digital analysis modules.

Abstract: The invention relates to a method for compiling a source code to a program code, the method comprising: providing a pattern graph based on the source code, the pattern graph corresponding to an intermediate representation of the source code according to a set of rules in a first programming language, wherein the set of rules comprises a specific replacement rule directing a pattern graph to be replaced by a corresponding replacement graph assigned to the pattern graph, replacing the pattern graph by the replacement graph assigned to the pattern graph, and generating the program code based on the replacement graph.

Abstract: The various implementations described herein include systems, methods and/or devices method for applying security policies in a virtualization environment. In one aspect, the method is performed at an electronic device of a plurality of electronic devices in a computing network, the electronic device having one or more processors and memory storing instructions for execution by the one or more processors. A plurality of user-space instances is instantiated. Furthermore, a security instance distinct from the plurality of user-space instances is instantiated. The security instance, which executes in user space of a respective virtual address space, monitors operations and data communications for the plurality of user-space instances. The security instance applies security policies to the monitored operations and data communications for the plurality of user-space instances so as to detect and/or remediate violations of the security policies.

Abstract: A method and apparatus for testing an application. The method displays, by a computer system, simulations of a graphical user interface for the application for a group of different types of devices on a display system. The method further displays, by the computer system, a group of controls in the graphical user interface displayed in the group of different types of devices on the display system. The method still further displays, by the computer system, a change to the graphical user interface in all of the simulations when a user input manipulates a control in a simulation in the simulations. A testing of the graphical user interface for the application for the group of different types of devices is enabled.

Abstract: Real-time application metrics of an application executed by a virtual machine are dynamically monitored by a controlling agent and analyzed to determine an optimal configuration of the virtual machine for executing the application. Based on the measured metrics, tunable parameters of the virtual machine may be adjusted to achieve desired application performance.

Abstract: Methods, systems, and devices are described herein for modifying the monitoring of the health of a data center IP endpoint (such as VM) during live migration of the data center IP endpoint from a source host to a destination host. In one example, the described techniques may include receiving an indication that a virtual machine is going to be live migrated from a source host to a destination host. Next, evaluation of health probe responses originating from the virtual machine may be suspended for a time period. The time period may be selected based on the live migration. The evaluation of the probe responses originating from the virtual machine may be resumed upon completion of the time period. In some cases, a health probe status of the virtual machine may be migrated from the source host to the destination host.

Abstract: A short pointer mode application is loaded in an address space configured for use by a plurality of types of applications including the short pointer mode application and a long pointer mode application. The address space has a first portion addressable by short pointers of a defined size and a second portion addressable by long pointers of another defined size. The other defined size is different from the defined size. Based on executing the short pointer mode application, one or more short pointers of the short pointer mode application are converted to one or more long pointers; and the one or more long pointers are used to access memory within the first portion of the address space addressable by short pointers.

Abstract: A processing system comprising a microprocessor core and a translator. Within the microprocessor core is arranged a hardware decoder configured to selectively decode instructions for execution in the microprocessor core, and, a logic structure configured to track usage of the hardware decoder. The translator is operatively coupled to the logic structure and configured to selectively translate the instructions for execution in the microprocessor core, based on the usage of the hardware decoder as determined by the logic structure.

Abstract: A quantum compiler is provided. The quantum compiler may generate, based on a text-based programmer input, an executable Hamiltonian for a quantum computer such as a quantum annealing computer or an adiabatic quantum computer. The quantum compiler may generate the program Hamiltonian by generating Hamiltonian phrases corresponding to portions of the programmer input and combining the Hamiltonian phrases. Various terms and values in the program Hamiltonian may correspond to physical features of the quantum computer so that the quantum computer can be operated, based on the program Hamiltonian, such that a low energy state of the quantum computer corresponds to the low energy state of the Hamiltonian.

Abstract: Method for sharing driver pages, including, on a computer system having a first driver and performing system services, instantiating Containers; code and data of the driver are loaded sequentially into pages arranged in a virtual memory, and instantiating a next driver upon a request from one of the Containers for system services by: loading physical pages of the next driver into physical memory and allocated virtual memory pages for the next driver; associating the next driver with the first driver and comparing pages of the next driver and the first driver, generating a set of identical physical pages; mapping virtual pages of the next driver to identical physical pages of the first driver while atomically protecting identical physical pages; non-identical pages of the next driver from physical memory remain mapped to virtual pages of the next driver; releasing physical memory occupied by identical physical pages of the next driver.

Abstract: A compiler-created cache contains target addresses of multiple indirect routine call sites. Ordinals assigned to indirect routine call sites are used with hardcoded offsets into the cache. Ordinals may be computed using a routine counter and an indirect call site counter. At runtime a target address of an indirect routine call site is compared to an entry in the cache using the hardcoded offset for efficiency. If the target address matches the cache entry, then a redundant call is avoided; otherwise, the call is not redundant, and the cache is updated. The call tested for redundancy may be a security check for malware, or a computationally expensive routine which calculates a return value without any side effects. Stack pointer validity may be checked. The cache may be guarded with code for trustworthy computing. Tail merging may be performed.

Abstract: The invention relates to a method for transforming a shared library between two operating systems with different application binary interfaces (ABIs) on a predetermined instruction set architecture. The shared library is implemented by a source object file comprising at least a source memory image, source symbol information, and absolute source relocation information. The method comprises: creating a target object header compliant to the target ABI and comprising information descriptive of the shared library and/or a target object file; creating a target memory image compliant to the target ABI from the source memory image; creating target symbol information compliant to the target ABI from the source symbol information; creating target relocation information compliant to the target ABI from the source relocation information; and writing the target object header, memory image, symbol information, and relocation information to the target object file to implement the transformed shared library.

Abstract: A method includes receiving source code in a first programming language. The method further includes identifying a design pattern based on a flag included in the source code. The method further includes generating a first translation of the source code in a second programming language, where at least a portion of the second file conforms to the design pattern. The method further includes generating a second translation of the source code in a third programming language. The method further includes outputting first data based on the first translation to a first device and second data based on the second translation to a second device.