Abstract: A user equipment (UE) a packet core system and method for common charging of network connectivity and cloud resource utilization for the UE. Upon receipt of a service request from the UE the packet core system sends a service definition of common network connectivity and cloud service classes. The UE sends a request for a network connectivity and cloud resource service with a common network connectivity and cloud service classes. The common class is translated into a first network connectivity class and a second cloud service class. A request for a cloud service comprising the second cloud service class is sent to a cloud node, and charging event is received from the cloud node. The charging event is merged with a charging event of network connectivity according to the first network connectivity class. A merged charging event, according to the requested common network connectivity and cloud service class, is achieved.

Abstract: Systems, methods, and other embodiments described herein relate to validating programs of a computing system in a vehicle by tracking a boot sequence. In one embodiment, a method includes, responsive to detecting initiation of a boot sequence in a computing system, tracking characteristics of programs executing as part of the boot sequence. The method includes determining whether the programs correspond with a program execution graph (PEG) by comparing the characteristics of the programs as the programs boot with the PEG. The method includes providing a response to thwart a malicious program when the boot sequence does not match the PEG.

Abstract: A computing system includes a quantum processor with qubits, a classical memory including a quantum program defining a plurality of instructions in a source language, and a classical processor configured to: (i) receive a circuit of gates representing a quantum program for a variational algorithm in which computation is interleaved with compilation; (ii) identify a plurality of blocks, each block includes a subcircuit of gates, leaving one or more remainder subcircuits of the circuit of gates outside of the plurality of blocks; (iii) pre-compile each block of the plurality of blocks with a pulse generation program to generate a plurality of pre-compiled blocks including control pulses configured to perform the associated block on the quantum processor; and (iv) iteratively execute the quantum program using the pre-compiled blocks as static during runtime and recompiling the one or more remainder subcircuits on the classical processor at each iteration of execution.

Abstract: Acceleration-ready program development includes providing a software library having a plurality of functions having compute identifiers. The software library is associated with a hardware library including one or more hardware accelerated functions. The hardware accelerated functions are associated with the compute identifiers. Each hardware accelerated function is a functional equivalent of a function of the software library having the same compute identifier. A hybrid executor layer is provided that, when executed by a data processing system with an acceleration-ready computer program built using the software library, is configured to initiate execution of a selected function of the acceleration-ready computer program using a processor of the data processing system or invoke a hardware accelerated function having a compute identifier matching the compute identifier of the selected function based on comparing acceleration criteria with acceleration rules.

Abstract: Systems and methods are provided for generating tables from print-ready digital source documents. A document is received and one or more text fragments are identified on a rendered page of the document. A wrapping region collection is generated, comprising one or more wrapping regions. A tabular, narrative and label score is generated for each wrapping region. A block type is assigned to each wrapping region based on the scores. A wrapping region group and a block set are generated. One or more tables are generated based on text fragments corresponding to one of the one or more blocks. The text fragments are organized into corresponding fields of the one or more tables.

Abstract: A system and method of selectively distributing blocks of a quantum assembly language (QASM) file over resources of a quantum computing environment to optimize performance of the quantum computing environment. The method includes receiving a quantum assembly language (QASM) file comprising a plurality of blocks. The method includes calculating a plurality of complexity scores each indicative of a degree of complexity to process a respective block of the plurality of blocks. The method includes calculating a plurality of risk scores associated with a pool of quantum computers, each risk score is indicative of a likelihood of a respective quantum computer of the pool of quantum computers entering an undesired state responsive to processing a respective block of the plurality of blocks. The method includes selectively distributing, based on the plurality of risk scores, each of the plurality of blocks to a single quantum computer of the pool of quantum computers.

Abstract: A method for implementing LINUX kernel hot patch, an electronic device and a computer readable medium, the method includes: modifying header instruction code of a patched function in an atomic operation mode, and jumping directly or indirectly from a patched function address to a patching function address to activate a patching function. The method for implementing LINUX kernel hot patch can achieve the activation of the patching function without restarting the LINUX system.

Abstract: A device may receive a preauthorization associated with missed transaction prevention for a transaction account of a user, wherein the missed transaction prevention involves preventing a missed transaction associated with merchant accounts of the user. The device may monitor a transaction log of the transaction account and identify a transaction pattern associated with a merchant account based on a plurality of historical transactions identified in the transaction log related to the merchant account. The device may determine that a historical transaction of the plurality of historical transactions is not designated for automatic execution and that an execution of an upcoming transaction corresponding to the plurality of historical transactions is not scheduled. The device may cause an account transaction associated with the upcoming transaction to be automatically executed before a transaction period expiration, associated with the merchant account, passes.

Abstract: This disclosure describes a system and method of automatically capturing source code and associated artifacts for static analysis. A method includes receiving a current state of a project that includes a set of files in a directory to be captured for analysis and a current capture status of individual files of the set of files, determining a plan including a sequence of actions in response to the current state of the project, and executing the sequence of actions to capture each of the set of files. The sequence of actions includes capturing buildable modules in the set of files with a build-capture based on a default build command and a buildless-capture based on module definition files.

Abstract: Garbage collection methods and systems include determining that a condition for performing concurrent marking has been met, based on object write frequency. It is determined that an opportunity for performing concurrent marking has occurred, based on a stop-the-world event. Performance of concurrent marking is delayed until a future stop-the-world event, to prevent pre-write barriers.

Abstract: Systems and methods for generating a platform-agnostic data pipeline via a low code transformation layer are disclosed. The system receives one or more user selections of (i) nodes and (ii) links linking the nodes, indicating a data pipeline architecture of transfer/management/flow of data via a GUI. In response to receiving a user selection to implement the data pipeline, the system automatically identifies/generates a set of code portions, based on one or more software objects (e.g., JSON objects) associated with the user selections indicating the data pipeline architecture. The system then identifies a platform identifier associated with a remote server and generates a set of executable instructions (e.g., a script, executable program, or other file) associated with the data pipeline architecture by using a transformation component. The system then provides the executable instructions to the remote server to host the data pipeline.

Abstract: A computing device displays a data visualization user interface that includes a schema region. Each data field displayed in the schema region is visually associated with a respective data object of a plurality of data objects in an object model. The device receives user input to specify a mathematical expression that includes a first data field from a first object and a second data field from a second object. The first object and the second object are distinct objects in the object model. The device generates a calculated data field based on the mathematical expression. The device assigns the calculated data field as a member of a third object in the object model according to relations in the object model connecting the first object to the second object. The device displays the calculated data field, in the schema region, visually associated with the third object.

Abstract: A computer implemented method includes detecting a current workstream of development tasks associated with a software development project. An activity attempting to access a resource is detected. Access rights to the resource are determined with respect to the activity as a function of the current workstream of development tasks. Access to the resource is controlled in accordance with the access rights.

Abstract: Embodiments are disclosed for inserting profiling instructions into graphics processing unit (GPU) kernels. An example apparatus includes instructions, and at least one processor to execute the instructions to determine whether a GPU supports modification of entry point addresses, detect a first entry point address and a second entry point address of an original GPU kernel, create a corresponding instrumented GPU kernel from the original GPU kernel based on the determination by inserting at least one of first profiling initialization instructions or first jump instructions at the first entry point address of the instrumented GPU kernel, inserting at least one of second profiling initialization instructions or second jump instructions at the second entry point address of the instrumented GPU kernel, and inserting profiling measurement instructions into the instrumented GPU kernel.

Abstract: Systems and methods for generating SLO specifications using annotations are generally described. In various examples, first source code associated with a first computer-implemented service is received. In various cases, a first annotation in the first source code may be received. The first annotation may include first metadata defining a name of an SLO specification. A second annotation in the first source code may be received. The second annotation may include second metadata defining a service-level objective (SLO) of a first aspect of the first computer-implemented service. In some cases, the first computer-implemented service may be executed using the first source code. In various examples, the SLO specification may be generated based on the first annotation and the second annotation.

Abstract: The described technology is generally directed towards causing the generation of a content selection graph (or set of graphs) upon receipt of a notification that a new graph or replacement graph is needed with respect to a starting timepoint. For a new graph, a timepoint for that new graph indicates the need for the new graph at a given starting time. For a replacement graph, a notification (subscribed from a monitoring service) can indicate that an existing graph has changed; a replacement graph is generated with a graph identifier of the replacement graph, which then replaces the graph identifier of the existing graph in the mappings of valid graphs to start times. A Redis cache can be used to maintain the various graph sets, including the active graph sets and graph sets that will become active at a future time.

Abstract: Apparatuses, systems, and techniques for caching of compiled shader programs in a cloud computing environment.

Abstract: Systems and methods are described for providing virtualized transaction retries in an on-demand network code execution system. A user may generate a task on the system by submitting code. The task may include a transaction that can succeed or fail depending on external factors, such as accessing a resource that other processes are also trying to access. The system may obtain success criteria for evaluating whether the transaction was successful, and may configure a virtual machine instance to execute the submitted code. The system may generate a “snapshot” or otherwise capture information regarding the state of the virtual machine instance prior to executing the code, and may then execute the code or a portion of it to attempt the transaction. The system may then apply the success criteria to determine whether the transaction was successful, and if not may retry the transaction by restoring the snapshot and re-executing the code.

Abstract: Computing systems that provide a modularized infrastructure for training Generative Adversarial Networks (GANs) are provided herein. For example, the modularized infrastructure can include a lightweight library designed to make it easy to train and evaluate GANs. A user can interact with and/or build upon the modularized infrastructure to easily train GANs. The modularized infrastructure can include a number of distinct sets of code that handle various stages of and operations within the GAN training process. The sets of code can be modular. That is, the sets of code can be designed to exist independently yet be easily and intuitively combinable. Thus, the user can employ some or all of the sets of code or can replace a certain set of code with a set of custom-code while still generating a workable combination.

Abstract: A compilation system accesses a compilation operations that can be used by a compiler to compile a design under test (DUT). The compilation system can determine a sequence of the compilation operations for the compiler to perform the compilation. The compilation system can detect a failure at a first compilation operation of the sequence of operations during the compilation of the DUT, and the compilation of the DUT can be paused after the failure is detected. The compilation system can determine a second compilation operation of the accessed compilation operations based on one or more netlist parameters of the DUT's netlist. The compilation system then modifies the sequence of compilation operations based on the second compilation operation and resumes the compilation of the DUT at the second compilation operation using the modified sequence of compilation operations.

Abstract: Systems and methods related to scheduling of tasks for execution in parallel based on geometric reach are described. An example method includes using a processor, processing information pertaining to a type of task to generate a plurality of areas of reach, where each of the plurality of areas of reach corresponds to a portion of a shared space. The method further includes using the processor, generating a plurality of inflated areas of reach by inflating each of the plurality of areas of reach based on a task-specific factor pertinent to the type of task. The method further includes automatically scheduling parallel execution of tasks associated with any of the plurality of inflated areas of reach satisfying a spatial constraint.

Abstract: Users of a graph data store can access an index object for a graph structure in order to obtain information from objects in the graph data structured index by the index object. A query can be received that is directed to an index object. Links to a subset of data objects in the data store included in the index object can be used to access the subset of data objects to perform the query. In some embodiments, data objects can be manually added or removed from the links included in the index object.

Abstract: Embodiments are disclosed for merging data structure definitions. The techniques include generating a first memory layout definition based on a first data structure definition that is written in a first programming language. The techniques further include generating a second memory layout definition based on a second data structure definition that is written in a second programming language. Additionally, the techniques include merging the first memory layout definition and the second memory layout definition into a merged memory layout definition. Further, the techniques include generating a merged data structure definition based on the merged memory layout definition.

Abstract: Garbage collection (GC) states are stored within references stored on a heap memory to track a progress of GC operations with respect to the references. GC state may be stored in a non-addressable portion of references. Based on the GC state of a particular reference, a set of GC operations are selected and performed for the reference. However, references stored on a call stack do not include any indication of GC state. Hence, loading a reference from heap to call stack involves removing the indication of GC state. Writing a reference to heap involves adding the indication of GC state. References embedded within a compiled method also do not indicate any GC state. Metadata of the compiled method indicate a GC state, which is implicated to the embedded references. GC operations are selected and performed for each embedded reference based on the GC state of the compiled method.

Abstract: Resolving conflicting changes to structured data files. A method includes for a structured data file which has both a generic structure and dialects built on top of the generic structure, for which conflicting changes have been made, and where an original version of the structured data, a first version of the structured data and a second version of the structured data exist, determining a dialect of the structured data. The method further includes, based on the determined dialect performing at least one of merge or diff operations on the original version of the structured data, the first version of the structured data and the second version of the structured data.

Abstract: Disclosed herein are methods, systems, and software for configuration change processing for end-user content request handling in content delivery nodes. In one example, a method of changing a content configuration for a content delivery node includes receiving a configuration change request by an end user. The method further provides, processing the configuration change request and a present configuration to generate a changed configuration comprising an assembly level code representation of the changed configuration, and transferring the changed configuration for delivery to the content delivery node.

Abstract: During a concurrent Relocation Phase, a GC thread relocates live objects, as an application thread executes. References in a frame on a call stack are remapped if the application thread attempts to access the frame. References on the call stack remains stale if no application thread attempts access. The GC thread may proceed with a subsequent phase of a GC cycle, even if a frame has stale references and therefore has not assumed a remap state. During a concurrent Mark/Remap Phase, the call stack may include frames in different frame states. The GC thread selects appropriate operations for processing each frame based on the respective frame state. When the GC thread encounters a frame not in the remap state, references therein are first remapped, and then identified as roots. Hence, root reference remapping and identification are performed in a single concurrent phase of a GC cycle.

Abstract: A network boot of a platform-specific operating system kernel is performed from a compressed platform-specific operating system kernel. The platform-specific operating system kernel, when booted, dynamically builds from the compressed platform-specific operating system kernel a bootable file system and boots application code. An application is loaded from the bootable file system.

Abstract: The endpoint agent detects a cyber threat on an end-point computing device. The endpoint agent on the computing device has a communications module that communicates with a cyber defense appliance. A collections module monitors and collects pattern of life data on processes executing on the end-point computing-device and users of the end-point computing-device. The communications module sends the pattern of life data to the cyber defense appliance installed on a network. The cyber defense appliance at least contains one or more machine-learning models to analyze the pattern of life data for each endpoint agent connected to that cyber defense appliance. The endpoint agent and the cyber defense appliance may trigger one or more actions to be autonomously taken to contain a detected cyber threat when a cyber-threat risk score is indicative of a likelihood of a cyber-threat is equal to or above an actionable threshold.

Abstract: Systems and methods are provided for generating tables from print-ready digital source documents. A document is received and one or more text fragments are identified on a rendered page of the document. A wrapping region collection is generated, comprising one or more wrapping regions. A tabular, narrative and label score is generated for each wrapping region. A block type is assigned to each wrapping region based on the scores. A wrapping region group and a block set are generated. One or more tables are generated based on text fragments corresponding to one of the one or more blocks. The text fragments are organized into corresponding fields of the one or more tables.

Abstract: Thermal imaging protection is provided by, in response to detecting input of an access code on an input device: identifying a sequence comprising the access code; generating a bait code based on the sequence; and outputting a heat signature corresponding to the bait code using heating elements, such as resistor arrays, included in the input device. In some embodiments protection includes measuring temperatures of contact surfaces of the input device where the access code has been input; and adjusting a heat level of the heating elements based on the temperatures measured. Protection is further provided by storing the bait code; and in response to receiving entry of the bait code, activating unauthorized access countermeasures. In some embodiments protection includes, in response to detecting subsequent input of the access code: generating a second, different, bait code based on the sequence; and activating the heating elements based on the second bait code.

Abstract: Some embodiments are directed to a compiler device (400) arranged for obfuscation of a computer program. The compiler device performs a live variable analysis on the computer program representation, and modifies the computer program representation to encode a first variable using at least a second variable as an encoding parameter.

Abstract: A system for detecting breach of merchant systems includes an extraction management system for extracting wildcard data from a dump site at which stolen account data is offered for sale. The system also includes an account breach identifying system for accessing stored transaction data from multiple banks and merging the extracted dump site data with the transaction data to create unique PAN (primary account number) data records (each set of wildcard data corresponds to only a single PAN) and multiple PAN data records (each set of wildcard data corresponds to multiple PANs). The unique and multiple PAN data records are stored and analyzed separately, and reduce the amount of data needed to identify a breached merchant.

Abstract: The described technology is directed towards an image providing service, including an image processing service that composites a base image into a resultant image, e.g., by resizing an image, overlaying text and so forth based upon a purpose for that image and/or a client device class; other parameters such as design information, protection and so forth also may be specified. When a client requests an image including by specifying a purpose and size in a request to an endpoint (e.g., URL) for an image, the image processing service locates or composites a resultant image corresponding to the request, and returns the resultant image or a modified (e.g., resized) resultant image in response to the request. Clients thus obtain images based upon a desired purpose without having to do client-side image processing including image compositing.

Abstract: The method includes identifying, by one or more computer processors, a program being utilized by a user. The method further includes identifying, by one or more computer processors, an environmental factor related to a user of the program. The method further includes determining, by one or more computer processes, a relationship between the program and the environmental factor. The method further includes generating, by one or more computer processors, one or more instructions for the program based at least in part on the determined relationship and the environmental factor.

Abstract: Embodiments herein disclose systems, methods, and computer-readable media for automatically transforming a code base. Using the code base as input, the code base is parsed, analyzed, and a modified code base is automatically generated. The code base may be modified by changing one or more assets in the code base based on the identification of path-to-path dependencies and/or interactions, in various embodiments. In some embodiments, the identifiers for globally exposed assets in the code base are modified to add imports or exports.

Abstract: Techniques for a code reviewer service to provide recommendations on source code are described. A code reviewer service may run rules and/or machine learning models to provide the recommendations. A machine learning model may identify one or more predicted issues of source code, and the code reviewer service may provide one or more recommendations based at least in part on the one or more predicted issues. Code reviewer service may allow a pull request for a code repository to trigger the generation of recommendations for the source code in the repository. The recommendations may be posted on the pull request.

Abstract: Systems and methods are disclosed for annotating a metadata catalog in a data intake and query system based on a detected change to the metadata catalog. The metadata catalog can store information about datasets associated with the data intake and query system, including dataset configuration records of the datasets, which can be used to process queries for execution by the data intake and query system. Based on a detected change to the metadata catalog, such as a manual or system annotation, the data intake and query system can generate additional annotations for the metadata catalog and use the annotations to update the metadata catalog.

Abstract: In one embodiment, the present disclosure pertains to automated data type determination of variables that are written in a programming language. In one embodiment, a programming language statement is received. The programming language statement includes a variable, an expression to which the variable is set, and a request to determine a data type of the variable. The expression is processed to deduce a data type of the expression. In certain embodiments, the data type of the expression is then assigned as the data type of the variable such that the data type can be used when the programming language statement is compiled into machine executable code.

Abstract: Systems, apparatuses and methods may provide for technology that detects one or more local variables in source code, wherein the local variable(s) lack dependencies across iterations of a loop in the source code, automatically generate pipeline execution code for the local variable(s), and incorporate the pipeline execution code into an output of a compiler. In one example, the pipeline execution code includes an initialization of a pool of buffer storage for the local variable(s).

Abstract: A disclosed example to protect memory from buffer overflow or underflow includes defining an implicit bound pointer based on an implicit bound pointer definition in a configuration file for a memory region; instrumenting object code with an implicit buffer bound check based on the implicit bound pointer; and generating hardened executable object code based on the object code, the implicit buffer bound check, and the implicit bound pointer, the implicit bound pointer located in the hardened executable object code during a compilation phase to facilitate loading the implicit bound pointer in a global bounds table during runtime for access by the implicit buffer bound check.

Abstract: Disclosed herein are techniques related to automated generation of regular expressions. In some embodiments, a regular expression generator may receive input data comprising one or more character sequences. The regular expression generator may convert character sequences into a sets of regular expression codes and/or span data structures. The regular expression generator may identify a longest common subsequence shared by the sets of regular expression codes and/or spans, and may generate a regular expression based upon the longest common subsequence.

Abstract: Systems and methods for supporting a compilation framework for hardware configuration generation. In one implementation, a processing device executing a compilation workflow for a target architecture may receive an input source code associated with a configuration for the target hardware architecture; identify a first configuration information associated with at least a portion of the configuration for the target hardware architecture; perform a first set of compilation passes of the input source code in view of the first configuration information; generate, in view of the first set of compilation passes of the input source code, a first internal representation component for the target hardware architecture; and generate, in view of the first internal representation component, a binary bitstream component for the target hardware architecture.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for using reactive programming operators to implement resource pooling. One of the methods includes receiving a first request, from a client application, for a poolable object in a resource pool and maintained by a resource pool manager, wherein the request indicates an operation mode specifying how the resource pool manager should release the poolable object back into the resource pool; generating a plurality of reactive programming operators comprising a poolable object listener publisher and a subscriber that is configured to subscribe to the poolable object listener publisher; evaluating the reactive programming operators in an upstream subscription ordering of the reactive programming operators to obtain a poolable object from the resource pool; and releasing the poolable object back to the resource pool according to the operation mode of the request.

Abstract: Run-time identification of dependencies during dynamic linking. A dynamic linker accesses contents of a first executable file that is to be executed. The dynamic linker, based on the contents of the first executable file, determines that the first executable file includes a first dynamic dependency function configured to be executed by the dynamic linker. The dynamic linker invokes the first dynamic dependency function of the first executable file. The dynamic linker receives, from the first dynamic dependency function, a first run-time dependency identifier that identifies a first run-time dependency, and adds the first run-time dependency identifier to a dependency identifier list.

Abstract: The present specification provides a method for executing a smart contract, a blockchain node, and a storage medium. An implementation of a method for executing a smart contract includes: receiving, by a blockchain node, a request for creating a smart contract, the request including a bytecode of the smart contract; starting, by the blockchain node after completing deployment of the smart contract, to compile the bytecode of the smart contract into a machine code by using ahead of time (AoT) compilation and storing the machine code; and during execution of a smart contract that has been deployed, interpreting and executing, by the blockchain node, a bytecode of the smart contract in response to that a machine code of the smart contract is not locally stored.

Abstract: A method and system for coordinating continuous delivery pipeline testing against a singleton instance of an application is disclosed. The method may include identifying a set of unchanged components across a preceding build and a current build of the singleton instance, and identifying a first set of test cases from a plurality of test cases executed on at least one unchanged component. The method may further include performing execution of a second set of test cases on the remaining set of unchanged components in the current build, and performing execution of each of the plurality of test cases on at least one changed component in the current build. The method may further include reporting test results of executing the first set of test cases on the at least one unchanged component, the second set of test cases, and the plurality of test cases.

Abstract: A method and apparatus are disclosed for upgrading libraries in a source code program by evaluating libraries in the source code program for predetermined selection criteria specifying library performance limitations to identify at least a first library which does not meet the plurality of predetermined selection criteria and then identifying a first alternative library that is suitable for substitution for the first library so that the source code program may be automatically modified to replace the first library with the first alternative library, thereby generating a modified source code program having an upgraded library functionality.

Abstract: Techniques and solutions are described for automatically refactoring code. In particular, disclosed technologies provide for automatically refactoring code that includes function calls, which can be to particular types of functions, such as external functions or functions that are not member functions of a class. For code to be refactored, an interface and a class are created. The class implements the interface. Method declarations corresponding to the function calls being refactored are added to the interface and the class. Code is added instantiating an object of the class. Implementations for the methods in the class can call the functions called by the source code being refactored, or can include code implementing the functionality of the called functions. Refactored code has function calls replaced with calls to corresponding methods of the interface.

Abstract: An application development environment providing system which provides a development environment for an application program via a network, wherein the network includes a first network which accommodates at least one device and which is communicatively connected to the device, and a second network communicatively connected to the first network, and wherein the application development environment providing system includes a program developer configured to classify processes included in the application program into a process executed in the first network and a process executed in the second network based on a predetermined determination condition, and to generate a first program execution file executed in the first network and a second program execution file executed in the second network in cooperation with the first program execution file.