Abstract: Techniques for managing lifecycles of sets of foreign resources are disclosed, including: opening, in a runtime environment configured to use a garbage collector to manage memory in a heap, a memory session; allocating a first subset of a set of foreign memory to a memory segment associated with the memory session, the foreign memory including off-heap memory that is not managed by the garbage collector; encountering, in the runtime environment, an instruction to close the memory session; responsive to encountering the instruction to close the memory session, deallocating the subset of the set of foreign memory.

Abstract: A method of porting a first application, corresponding to a third-party development tool, into a second application, corresponding to a sub-application that depends on a parent application to run, is performed by an electronic device. The device transforms the first application from a first project mechanism into a second project mechanism. The device converts a design resource in the transformed first application from a first resource format into a second resource format. The device exports the design resource to a development tool of the sub-application. The device converts a code resource in the transformed first application from a first programming language into a second programming language. The device exports the code resource to the development tool of the sub-application. The device also performs secondary development on the design resource and the code resource in the development tool of the sub-application.

Abstract: According to one or more embodiments of the disclosure, an example process herein may comprise: receiving configuration of an extension to manage one or more particular endpoints and data collectors for a particular tenant of an extensibility platform; determining a specification of a container containing one or more particular functions configured to perform required data transformations for the extension; providing one or more shared egress assistant functions configured to receive data from the one or more particular functions; and sending the data from the one or more shared egress assistant functions onto a common ingest for further processing, wherein the one or more particular functions and the one or more shared egress assistant functions are executed as functions-as-a-service at runtime.

Abstract: An upgrading method, includes: a server first sends a version check command to a terminal device; then receives feedback data sent by the terminal device based on the version check command; and sends an upgrade command to the terminal device in response to the terminal device being to be upgraded, wherein whether the terminal device is to be upgraded is determined based on the feedback data.

Abstract: Systems, methods and products for intelligent delivery of communications, where a machine learning engine is trained to identify an output channel for delivery of a communication based on received context information and intended recipient information and to route the communication to the selected channel. An intelligent delivery task in a communication flow model is performed by the machine learning engine, which receives customer/recipient data such as age, region, gender, etc., and context data such as communication type, time of day, working hours, etc., and uses this data to determine which of a set of different channels is likely to be most effective for sending the communication to the recipient. A user therefore does not have to build a complex static communication flow, but simply adds an intelligent delivery task to the flow. The output channel is dynamically selected and may vary for different recipients and communications.

Abstract: A method includes identifying a portion of a web application to be migrated from a first to a second web application framework, selecting at least one page element in the portion of the web application that is to be migrated, generating an application chunk for the selected page element as a self-contained web application that utilizes the second web application framework, and replacing a portion of software code of the web application corresponding to the selected page element with chunk definition metadata defining content of the selected page element, dependencies of the selected page element, and triggers for loading the generated application chunk. The method also includes creating an application core comprising a user interface shell configured to load the generated application chunk and one or more other application chunks of the web application responsive to activation of user interface elements of the web application corresponding to the defined triggers.

Abstract: A method includes receiving a request to modify a first value of a first field of a first item in a self-describing data system, and obtaining a domain comprising items in the self-describing data system. The first item and a second item are included in items, and the second item comprises a second field having a second value. The method includes calculating, based on a rule of the second field, a dependency of the second value on the first value. The rule specifies how the second value is to be calculated using the first value. The method includes modifying, based on the request, the first value. The method includes receiving an event triggered by the modification to the first value. The method includes, responsive to the event, calculating the second value based on the rule, and storing the second value in the second field.

Abstract: A system for generating user interface (UI) components in a web-based interactive UI is disclosed. Instructions, when executed by processors, cause the processors to receive CSS files specifying a desired standardized appearance for UI components, receive an HTML file specifying the interactive UI and including tags not specified by any HTML standard, corresponding to one or more UI components; and provide a webpage comprising the UI components to a human user. When rendered and executed by a web browser of the human user, the web browser will render the UI components indicated by the tags, load data into the UI components and style the UI components in accordance with the CSS file. The browser will also receive input requesting a change to presentation of data in the UI components and update UI components in accordance with the requested change. Additional features improving datagrid, chart, and filter functionality are provided.

Abstract: A code notebook and backend cloud service are configured to intelligently analyze program source code that a developer wants analyzed. A user drafts a code query to be answered about the source code that may specify specific variables, code structure elements, and/or program flows to be scrutinized. A cloud-computing environment builds a code database of the source code and analyzes its text, code structures, and program flows. The code database is embedded with indications of semantic equivalences for text in the source code, identifications of different code structural elements, and program flows. In the cloud-computing environment, a query service takes the code query of the developer and queries the database with machine-learned embeddings, generating query results that are shared with the developer and shown in a representation of the source code.

Abstract: A method of executing computer-readable code for interaction with one or more data resources on a data processing platform, the method performed using one or more processors, comprising: receiving a request message including an identifier identifying executable code stored in a data repository; determining, using the identifier, an execution environment of a plurality of stored execution environments mapped to the identified executable code, wherein determining the execution environment mapped to the identified executable code comprises: accessing mapping data identifying a mapping between the identifier and the execution environment of the plurality of stored execution environments, the mapping data including configuration data associated with the identifier, wherein the configuration data identifies one or more convention-based data libraries particular to the execution environment; configuring the determined execution environment to access the one or more convention-based data libraries during execution; e

Abstract: The present disclosure relates to a deep learning algorithm compiling method and a device and a related product, the product comprising a controller unit, and the controller unit comprising: an instruction cache unit, an instruction processing unit, and a queue-storing unit. The instruction cache unit is configured to store computation instructions associated with artificial neural network operations. The instruction processing unit is configured to parse the computation instructions to obtain a plurality of operation instructions. The queue-storing unit is configured to store an instruction queue, which comprises: a plurality of operation instructions or computation instructions to be executed according to the front-to-rear sequence of the queue. By means of the described method, the present disclosure may improve the operation efficiency of the related product when carrying out neural network model operations.

Abstract: Relationship-apparent application artifact registration is performed by attaching, to the bundle service specification, a bundle identifier, the principal address, and an artifact relationship specification, the artifact relationship specification representing, for each of the one or more artifact service specifications, the subordinate address, the artifact identifier, and the artifact type of each represented artifact, and attaching, to each of the one or more artifact service specifications, a bundle relationship specification, the bundle relationship specification representing the bundle identifier and the principal address.

Abstract: In an example implementation according to aspects of the present disclosure, a method for creating a hash map comprising at least one entries corresponding to at least one executable control blocks, storing the execution control blocks in a shared function address space, and executing the at least one executable control blocks based on referencing a corresponding entry in the hash map.

Abstract: A code hot-update method and terminal are provided. The method includes: code to be hot-updated is translated into first-type intermediate code, wherein the first-type intermediate code is compiled by using a compiler of a target-type operating system; the first-type intermediate code is translated into bytecode to be run, wherein the bytecode to be run is interpreted by an interpreter of the target-type operating system; and the bytecode to be run is interpreted by using the interpreter to hot-update the code to be hot-updated.

Abstract: A consumer may initiate a transaction using a transaction account. The transaction account issuer may transmit a notification to the consumer that the transaction has been authorized. The consumer may select requestees with whom to split the transaction. The transaction account issuer may transmit notifications to requestees to request payment from the requestees. The transaction account issuer may transfer the payment from a transaction account of the requestee to the consumer's transaction account.

Abstract: Systems and methods providing a processing device to receive, by a software build process executing in a trusted execution environment (TEE) of a first computer system, software source code from a second computer system. The processing device generates a software package by compiling the software source code. The processing device also generates a first signature of the software package and sends the first signature to the second computer system. Responsive to receiving, from the second computer system, a second signature comprising the first signature signed by the second computer system, the processing device further deploys the software package on the first computer system.

Abstract: A system includes a memory, a processor in communication with the memory, and a compiler. The compiler is configured to initialize at least one class for an application at compilation time, start a framework at compilation time, and serialize a framework container of the framework into a native image at compilation time. The processor is configured to run the native image to start the application.

Abstract: Multiple execution traces of an application are accessed. The multiple execution traces have been collected at a basic block level. Basic blocks in the multiple execution traces are scored. Scores for the basic blocks represent benefits of performing binary slimming at the corresponding basic blocks. Runtime binary slimming is performed of the application based on the scores of the basic blocks.

Abstract: The present disclosure provides methods and devices for simulating a design, wherein the design comprises a main class with parameters and a plurality of instances of the main class, wherein the plurality of instances comprise a first instance and a second instance. The method includes: determining, by analyzing the design, a plurality of secondary classes associated with instantiating the main class, wherein the plurality of secondary classes are used as the parameters of the main class and comprise a first secondary class corresponding to the first instance and a second secondary class corresponding to the second instance; translating the design to generate a first temporary code associated with the plurality of instances; generating, based on the first temporary code, a plurality of instance machine codes corresponding to the plurality of instances; and simulating the design based on the plurality of instance machine codes.

Abstract: A computing device including a processor configured to receive source code including a plurality of source code modules. The processor may generate executable code from the source code and assign two or more reload indicators to two or more executable code modules. The processor may execute the executable code. During execution of the executable code, the processor may receive a source code update and generate an executable code update from the source code and the source code update. The processor may apply the executable code update to the executable code to generate updated executable code. The processor may generate a reload ordering of two or more reload operations corresponding to the reload indicators. As specified by the reload ordering, the processor may perform the two or more reload operations at the two or more respective executable code modules. The processor may execute the updated executable code.

Abstract: A method of executing computer-readable code for interaction with one or more data resources on a data processing platform, the method performed using one or more processors, comprising: receiving a request message including an identifier identifying executable code stored in a data repository; determining, using the identifier, an execution environment of a plurality of stored execution environments mapped to the identified executable code, wherein determining the execution environment mapped to the identified executable code comprises: accessing mapping data identifying a mapping between the identifier and the execution environment of the plurality of stored execution environments, the mapping data including configuration data associated with the identifier, wherein the configuration data identifies one or more convention-based data libraries particular to the execution environment; configuring the determined execution environment to access the one or more convention-based data libraries during execution; e

Abstract: Aspects of the invention include a computer-implemented method that receives, by a processor, an ensemble decision tree and generates, by the processor, native code from the ensemble decision tree. The method compiles, by the processor, the native code into machine language and scores, by the processor, the execution time of the native code. The method dynamically reoptimizes, by the processor, portions of the native code corresponding to the most traversed portion of the ensemble decision tree.

Abstract: Techniques for representing a native function using an executable reference are disclosed. The system receives an instruction to create an executable reference for a native function, including a method type comprising a method signature corresponding to the executable reference, and a function description including (a) a memory layout corresponding to data returned by the function and (b) memory layouts corresponding to parameters required by the function. The system selects an application binary interface (ABI). The system generates code that, for each parameter, of the one or more parameters required by the function, converts the parameter from a value formatted for use by a Java Virtual machine to a value formatted for use in the native function, based on the selected ABI. Responsive to invocation of the executable reference, the generated code and the native function may be executed.

Abstract: Methods and apparatus to customize deployment using approvals are disclosed. An example deployment approval manager can generate a first Approval Payload including an initial application component approval proposal of an application component that provides a logical template of an application. A deployment event broker can reply-back to the deployment approval manager with a second approval payload that includes a processed application component approval proposal.

Abstract: Techniques for managing backup plans in information processing systems are disclosed. For example, a method comprises managing a data backup plan for an information processing system comprising a set of host devices that execute application instances for which data is stored on a first storage system and mirrored on a second storage system. After a given condition is detected, managing the data backup plan comprises reconfiguring the data backup plan by: (i) automatically subscribing, to the data backup plan, one or more of the application instances that execute on one or more active ones of the set of host devices configured to store data on the second storage system; and (ii) automatically unsubscribing, from the data backup plan, one or more of the application instances that previously executed on one or more non-active ones of the set of host devices configured to store data on the first storage system.

Abstract: A streamlined approach enables customers to retain management control over their data in a database-as-a-service (“DBaaS”) setting, by providing managed backup copies outside cloud service providers' sphere of control. An illustrative data storage management system provides control over performing backup operations to generate managed backup copies, storing managed backup copies, recovering managed backup copies in whole or in part, migrating managed backup copies, and migrating DBaaS instances. Management control also extends to choices of where to store the managed backup copies, whether on the same cloud computing platform as the source DBaaS, on a different cloud computing platform, and/or in a non-cloud data center.

Abstract: A computer-implemented method (and corresponding system) is provided that enables or facilitates the execution of a portion of source code, written in a high-level language (HLL), on a blockchain platform. The method and system can include a blockchain compiler, arranged to convert a portion of high-level source code into a form that can be used with a blockchain platform. This may be the Bitcoin blockchain or an alternative. The method can include: receiving the portion of source code as input; and generating an output script comprising a plurality of op codes. The op codes are a subset of op codes that are native to a functionally-restricted, blockchain scripting language. The outputted script is arranged and/or generated such that, when executed, the script provides, at least in part, the functionality specified in the source code.

Abstract: Computer-implemented methods, non-transitory, computer-readable media, and computer-implemented systems are provided for executing a smart contract in a blockchain network. A computer-implemented method includes: in response to determining that bytecodes of a smart contract are deployed on a first blockchain node in a blockchain network, starting, by the first blockchain node, to compile the bytecodes of the smart contract into machine codes of the smart contract through a Just-In-Time (JIT) compiler; determining, by the first blockchain node, that the machine codes of the smart contract are not locally stored and that execution results of the machine codes of the smart contract and the bytecodes of the smart contract are consistent; and in response to the determining, performing, by the first blockchain node, interpretation execution on the bytecodes of the smart contract.

Abstract: A computing device including a processor configured to receive source code including a plurality of source code modules. The processor may generate executable code from the source code and assign two or more reload indicators to two or more executable code modules. The processor may execute the executable code. During execution of the executable code, the processor may receive a source code update and generate an executable code update from the source code and the source code update. The processor may apply the executable code update to the executable code to generate updated executable code. The processor may generate a reload ordering of two or more reload operations corresponding to the reload indicators. As specified by the reload ordering, the processor may perform the two or more reload operations at the two or more respective executable code modules. The processor may execute the updated executable code.

Abstract: Secure backwards compatible orchestration of isolated guests is disclosed. For example, a current version of an isolated guest orchestrator instantiates an older version of the isolated guest orchestrator in a host as a dependent compute service. An application programming interface request is received. The application programming interface request is determined to be unsupported by the current version of the isolated guest orchestrator. The application programming interface request is sent to the dependent compute service. The application programming interface request is responded to based on a response from the dependent compute service.

Abstract: A computer-implemented method is disclosed that includes receiving content associated with a heap dump of a computer application, generating a plurality of files based on the heap dump content, and loading the files into the graph database. The files so generated are compatible with the graph database. In some implementations, additional analysis and route finding (e.g., finding the relationship between two nodes) may be performed on the resulting object graph.

Abstract: Embodiments relate to a compiler. The compiler decreases data fetch and read associated with storing data in a data buffer of a neural processor circuit to or from a system memory. The data buffer can store an input slice of data for processing by a neural engine(s) of the neural processor circuit, an output slice of data output from the neural engine(s), and/or an intermediate data slice of data.

Abstract: A method for detection of tampering in an executable code including one or more code blocks. The method includes monitoring execution of the executable code with a call stack data structure associated therewith, the execution involving accessing one or more address spaces; receiving information about the one or more address spaces, as accessed; comparing the received information about one or more accessed address spaces with information about one or more allowed address spaces defined in the call stack data structure of the executable code; raising a flag upon detection that the one or more accessed address spaces are different from the one or more allowed address spaces, based on the comparison; and executing an action based on the raised flag.

Abstract: Techniques for accessing off-heap memory are disclosed. The system may receive a memory segment layout definition for a memory segment in a physical memory of a machine. The memory segment layout definition defines a number of elements and a number of sub-elements in each element of the plurality of elements. The system may allocate the particular memory segment in the physical memory and may store a reference to a position of a sub-element. The system may receive a request to access a first sub-element of a particular element of the plurality of elements. Based on the request, the system may identify the memory segment corresponding to the plurality of elements, identify the particular element of the plurality of elements, identify the first sub-element of the plurality of elements based the position of the first sub-element, and execute an Input or Output (IO) operation corresponding to the request.

Abstract: A computer-implemented method comprises obtaining an intermediate computer code object including a set of instructions corresponding to a task to be performed. The intermediate computer code object—being machine independent—further includes for each of the at least one set of instructions one or more metadata descriptors representative of at least a complexity measure of the task to be performed. The method also comprises executing the intermediate computer code object on a computing platform comprising at least two different execution units having a different memory with a different memory location. This executing comprises selecting for each of the at least one set of instructions a target execution unit from the plurality of execution units. This selecting takes the one or more metadata descriptors and a decision rule into account, wherein the decision rule relates the plurality of complexity measures to a performance characteristic of the plurality of execution units.

Abstract: A method of executing computer-readable code for interaction with one or more data resources on a data processing platform, the method performed using one or more processors, comprising: receiving a request message including an identifier identifying executable code stored in a data repository; determining, using the identifier, an execution environment of a plurality of stored execution environments mapped to the identified executable code, wherein determining the execution environment mapped to the identified executable code comprises: accessing mapping data identifying a mapping between the identifier and the execution environment of the plurality of stored execution environments, the mapping data including configuration data associated with the identifier, wherein the configuration data identifies one or more convention-based data libraries particular to the execution environment; configuring the determined execution environment to access the one or more convention-based data libraries during execution; e

Abstract: A computer-implemented method is provided for compilation rescheduling from among four compilation levels comprising level 1, level 2, level 3, and level 4 on a parallel distributed computing framework running processes for a plurality of jobs of a virtual machine. The method bypasses a program analysis overhead that includes measuring a compiled method execution time by identifying completed compilation levels of a Just In Time compilation. The method finds a repetition of a same process in the processes for the plurality of jobs of the virtual machine from profiles by comparing main class names, virtual machine parameters, and Jar file types therein.

Abstract: Embodiments relate to a system, program product, and method for evaluating and controlling configuration of a build manifest. An application build manifest is discovered and is subjected to parsing process in which one or more components that comprise the application are identified. The build manifest is monitored for changes to the identified components, and a change notification is generated in response to a change in an identified component. Each generated change notification is assigned a classification. The change notifications are applied selectively to update the manifest, wherein the selective update is based on the classification of the change notification.

Abstract: A method includes replicating a data pattern to be searched for, storing the replicated data pattern into a first row of memory cells, and comparing the replicated data pattern to data stored into a second row of memory cells. In response to detecting the data pattern in the data stored into the second row of memory cells, storing into a third row a value indicative of at least one of an occurrence of the data pattern or a position of the searched for data pattern in the data stored into the row of memory cells.

Abstract: Example systems relate to system call acceleration. A system may include a processor and a non-transitory computer readable medium. The non-transitory computer readable medium may include instructions to cause the processor to run a plurality of benchmarks for a hardware configuration. The non-transitory computer readable medium may further include instructions to determine a benchmark matrix based on the plurality of benchmarks. The non-transitory computer readable medium may include instructions to determine an input/output (I/O) bandwidth ceiling for the hardware configuration based on the benchmark matrix. Additionally, the non-transitory computer readable medium may include instructions to determine a performance threshold of an I/O access parameter for the hardware configuration based on the bandwidth ceiling.

Abstract: An apparatus and method for dynamic provisioning and traffic control on a memory fabric.

Abstract: A device may receive, from a virtual machine deployed on the device, a request to register for an event associated with a hardware component of the device, and may create a path to a script associated with providing information about the event when the event occurs. The device may provide the script to an event plugin associated with the event and the hardware component, and may register the event plugin with a kernel associated with the device. The device may receive, the kernel, information indicating occurrence of the event associated with the hardware component, and may cause, via the event plugin, execution of the script based on the occurrence of the event associated with the hardware component. The device may provide, based on execution of the script, a notification to the virtual machine, where the notification may indicate the occurrence of the event associated with the hardware component.

Abstract: Device operation across multiple operating system modalities, including: performing, by a first operating system, one or more device initialization operations for a device; determining that the device is in an initialized state; and performing, by a second operating system, one or more device operations of the device in the initialized state.

Abstract: Technologies for optimized binary translation include a computing device that determines a cost-benefit metric associated with each translated code block of a translation cache. The cost-benefit metric is indicative of translation cost and performance benefit associated with the translated code block. The translation cost may be determined by measuring translation time of the translated code block. The cost-benefit metric may be calculated using a weighted cost-benefit function based on an expected workload of the computing device. In response to determining to free space in the translation cache, the computing device determines whether to discard each translated code block as a function of the cost-benefit metric. In response to determining to free space in the translation cache, the computing device may increment an iteration count and skip each translated code block if the iteration count modulo the corresponding cost-benefit metric is non-zero. Other embodiments are described and claimed.

Abstract: A method of executing computer-readable code for interaction with one or more data resources on a data processing platform, the method performed using one or more processors, comprising: receiving a request message including an identifier identifying executable code stored in a data repository; determining, using the identifier, an execution environment of a plurality of stored execution environments mapped to the identified executable code, wherein determining the execution environment mapped to the identified executable code comprises: accessing mapping data identifying a mapping between the identifier and the execution environment of the plurality of stored execution environments, the mapping data including configuration data associated with the identifier, wherein the configuration data identifies one or more convention-based data libraries particular to the execution environment; configuring the determined execution environment to access the one or more convention-based data libraries during execution; e

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

Abstract: A processor may initiate a first verification event. The first verification event may be triggered when a mobile device begins generating new data at a first time. The processor may determine, in response to the first verification event, that the mobile device is above a threshold limit of available storage. The processor may analyze one or more applications on the mobile device. The processor may automatically remove a first re-downloadable portion of a first application binary interface associated with a first application from the mobile device. The processor may store the generated new data on the mobile device.

Abstract: A system is described for high-performance delivery of applications via attachable application storage volumes (ASV), particularly in cloud-based VDI environments, by precaching application data that is determined by learning the application behavior. Data blocks for files that are likely to be used by the application are prefetched and cached by virtual machines before the application requests those blocks so that the relevant data is instantly available in memory when required without needing to wait for the data to be transmitted from the ASV. In order to efficiently prefetch content, the read pattern for application files and their corresponding blocks is inspected. This information is used during application delivery after a user logs onto the virtual machine to selectively prefetch those blocks from the ASVs. As a result, when the user launches those applications, the system avoids the performance penalty of reading those blocks from the ASV.

Abstract: Embodiments of the present disclosure relate to software application optimization. Other embodiments may be described and/or claimed.

Abstract: Disclosed aspects relate to managing a stream computing environment. The stream computing environment may have a consistent region that includes a set of stream operators for processing a stream of tuples. An operator modification request with respect to the set of stream operators of the consistent region of the stream computing environment may be received. In response to receiving the operator modification request, a set of tuples of the stream of tuples may be detected in the consistent region. Using the operator modification request, a tuple adjustment action for the set of tuples of the stream of tuples in the consistent region may be determined. Based on the operator modification request, the set of stream operators may be modified. The set of tuples may be processed using the tuple adjustment action.