Abstract: Removing inactive components to facilitate code generation. A first file that includes a first group of components in a first notation syntax and a second file that includes a second group of components in a second notation syntax is received. A first set of inactive components of the first group of components is identified. A second set of inactive components of the second group of components is identified. The components of the first group of components and the second group of components that are not marked as inactive components are active components. Code to be executed based on the active components is generated.

Abstract: A method may include obtaining, for an application, application dependency specifications, identifying vulnerable components using the application dependency specifications and a list of known vulnerable components, selecting, for a vulnerable component, candidate dependency specifications each specifying a version ID for a component, selecting, for a candidate dependency specification, an upgraded version ID for a component, verifying, using an application dependency graph generated from the application dependency specifications, that upgrading the candidate dependency specification to the upgraded version ID removes a dependency on the vulnerable component, and recommending, for the application, an upgrade solution including upgrading the candidate dependency specification to the upgraded version ID.

Abstract: A carbon footprint associated with executing a job on one or more computer nodes can be automatically managed using some techniques described herein. As one particular example, a system can determine a first carbon footprint associated with applying a continuous integration (CI) pipeline to source code using a first set of nodes of a continuous integration system. The system can also select a second set of nodes of the continuous integration system, the second set of nodes being associated with a second carbon footprint that is lower than the first carbon footprint. The system can then control the continuous integration system to apply the CI pipeline to the source code using the second set of nodes.

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: Methods and systems are presented for facilitating development and execution of application programming interfaces (APIs) using a software orchestration framework. Using the software orchestration framework, APIs may be developed using declarative statements only, without requiring any implementation using programming code. Based on parsing and interpreting the declarative statements at runtime, computer processing logic for the API can be determined dynamically. The computer processing logic may include instructions for validating input values included in a corresponding API call and a set of services to be executed for the API. Since the software orchestration framework can dynamically determine and execute the computer programming logic based on the declarative statements corresponding to the API, the business logic associated with an API can be dynamically modified without requiring recompiling and/or re-deploying of the software orchestration framework.

Abstract: Methods, systems, and computer-readable storage media for receiving data representative of two or more AAGs, providing an identifier for each element of each of the two or more AAGs, each identifier being unique within a respective AAG, at least one identifier being non-unique between the two or more AAGs, determining an attribute value for each element of each of the two or more AAGs, storing attribute value to element mappings in an attribute dictionary, providing a differenced AAG based on the attribute value to element mappings in the attribute dictionary, determining a set of remedial actions at least partially based on the differenced AAG, and executing one or more remedial actions in the set of remedial actions to reduce a cyber security risk to the enterprise network.

Abstract: A shim layer can be incorporated into a container image for intercepting calls between an upper layer and a lower layer of the container image according to some aspects described herein. For example, a system can build an image file that includes a stacked arrangement of layers configured for deploying a software program within a container. The stacked arrangement of layers can include a lower layer including one or more objects. The stacked arrangement of layers can include an upper layer positioned above the lower layer, where the upper layer includes the software program. And the stacked arrangement of layers can include a shim layer positioned between the lower layer and the upper layer. The shim layer can include a shim, which is configured to intercept calls involving the one or more objects from the software program and responsively allow or reject the calls based on control data.

Abstract: Described are examples for providing fine-grained real-time pre-emption of codelets based on a runtime threshold. A controller inserts checkpoints into extended Berkeley packet filter (eBPF) bytecode of a third-party codelet prior to verification of the third-party codelet. A device executes the codelet at a hook point of an application. The inserted checkpoints determine a runtime of the codelet. The device terminates the codelet in response to the runtime exceeding a threshold. The application can be a virtualized radio access network (vRAN) network function and the codelet can control the vRAN function or export network metrics. The application may be executed in a container management system that modifies a container for the application to mount code including a function associated with the hook point of the application to the container; detect an annotation for the container that identifies the codelet; and symbolically links the codelet to the hook point.

Abstract: A build process for building software in a target environment can be generated using a system described herein. For example, the system can receive a recommended software-stack for a target software item to be built in a target build environment. The system can determine, based on the recommended software-stack, a build process for building the target software item in the target build environment. The system may then execute the build process to generate a software build of the target software item in the target build environment.

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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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.