Abstract: Disclosed here are systems and methods that allow users, upon detecting errors within a running workflow, to either 1) pause the workflow and directly correct its design before resuming the workflow, or 2) pause the workflow, correct the erred action within the workflow, resume running the workflow, and afterwards apply the corrections to the design of the workflow. The disclosure comprises functionality that pauses a single workflow and other relevant workflows as soon as the error is detected and while it is corrected. The disclosed systems and methods improve communication technology between the networks and servers of separate parties relevant and/or dependent on successful execution of other workflows.

Abstract: Methods to execute an orchestration of computing services concurrently, the method including developing a representation of a set of services where each service relates to other services via different types of relationships. Also, applying a set of dependency rules for each type of relationship within the set of services such that the application of the dependency rules creates inter-step dependencies between steps representing state transitions of the set of services and developing the orchestration plan based on the inter-step dependencies that allows for concurrent execution of nondependent steps.

Abstract: Efficiently implemented herein is a deterministic semantic for property updates by graph queries. Mechanisms of determinism herein ensure data consistency for graph mutation. These mechanisms facilitate optimistic execution of graph access despite a potential data access conflict. This approach may include various combinations of special activities such as detecting potential conflicts during query compile time, applying query transformations to eliminate those conflicts during code generation where possible, and executing updates in an optimistic way that safely fails if determinism cannot be guaranteed. In an embodiment, a computer receives a request to modify a graph. The request to modify the graph is optimistically executed after preparation and according to safety precautions as presented herein. Based on optimistically executing the request, a data access conflict actually occurs and is automatically detected.

Abstract: A method and system are provided that apply a combination of machine learning and graph techniques to classify and transform sequential event data. In some embodiments, the method and system are applied to generate raw data in the shipping industry to automatically classify a sequence of status codes extracted from EDI data files corresponding to a series of physical events experienced by a shipping container into a sequence of meaningful milestones to provide improved visibility regarding the actual status of the shipping container. The method and system can be applied to classify and transform sequential event data for use in the shipping industry and in other applications.

Abstract: A method may include accessing a data processing architecture associated with a neural network to determine dependencies between intermediate data layers of the neural network; obtaining dimensions of the intermediate data layers in the neural network; calculating a minimum number of data storage portions for executing the neural network based on the dependencies; determining a memory allocation size for each respective data storage portion of the data storage portions based on the dimensions and dependencies; allocating memory on a storage device for each data storage portion in accordance with its respective determined memory allocation size.

Abstract: An autonomic method for the comprehensive profiling of near or real time representations of time sequenced, synchronized, characterized business activity by any entity within a group of commercially related subscribing business partners, for the purpose of creating a near or real time universal business activity mosaic. An autonomic method within a group of commercially interrelated businesses to utilize a universal business activity mosaic to render a virtual customer storefront, whereby a business may discretely witness in time and character the sale of its own assets and services either fully or partially comprising those sold to anybody of related intermediate or end customers for the purpose of purchasing, selling, financing, warehousing or physically transporting assets on demand.

Abstract: Disclosed herein is a technique for enabling isolated processes executing within a web browser to distribute information to one another. The method can be implemented by a first process executing within the web browser, and include the steps of (1) receiving, from a child process executing within the web browser, a first request to subscribe to a topic, (2) in response to identifying that the child process is not subscribed to the topic: updating a topic map to indicate that the child process is subscribed to the topic, and (3) in response to identifying that the first process is associated with the parent process: issuing, to the parent process, a second request for the first process to subscribe to the topic. Also disclosed herein is a method for enabling a first process executing within a web browser to access services provided by other processes executing within the web browser.

Abstract: A software update management apparatus includes a storage unit adapted to divide a network into one or more blocks and store block management information indicating whether each of network devices belonging to each of the resulting blocks is an active device or a standby device; an update instruction receiving unit adapted to receive software update instructions; a software update information generating unit adapted to generate software update information; a software updating unit adapted to perform software update processes after transferring traffic to standby devices in same blocks as respective active devices when it is determined that the network devices are active devices according to the software update information and thereby perform the software update processes for active devices or standby devices in different blocks in parallel.

Abstract: A method for optimizing memory access for database operations is provided. The method may include performing a first database operation by at least executing a first instruction stream associated with the first database operation. The first database operation may be defined as a coroutine to at least enable the execution of the first instruction stream to be interleaved with an execution of a second instruction stream. In response to determining that data required to continue the execution of the first instruction stream is absent from a cache, the execution of the first instruction stream may be suspended and the second instruction stream may be executed instead. Related systems and articles of manufacture, including computer program products, are also provided.

Abstract: A computer device for characterising execution time by a processor, comprising a memory (8) which receives benchmark program data, sets of characterisation configuration data and sets of execution case data, and a constructor (4) which determines, for each set of execution case data, a set of worst-case configuration data of the processor and a set of initialisation values based on a set of execution case data, and determining a reference execution time by executing the benchmark program according to the set of execution case data using the processor configured with the set of configuration data with the set of initialisation values, all the reference execution times forming a set of reference execution times.

Abstract: A method includes: identifying, by a first program module, a bucket having an object lifecycle management rule in a dispersed storage network; creating, by a second program module, ranges of object names included in a namespace of the bucket; determining, by a third program module and for respective objects in each of the ranges, whether the respective objects satisfy the object lifecycle management rule of the bucket; and performing, by a fourth program module and based on the determining, an action on one of the respective objects that satisfies the object lifecycle management rule, the action being defined by the object lifecycle management rule.

Abstract: A method includes receiving, by a L2 controller, a request to perform a global operation on a L2 cache and preventing new blocking transactions from entering a pipeline coupled to the L2 cache while permitting new non-blocking transactions to enter the pipeline. Blocking transactions include read transactions and non-victim write transactions. Non-blocking transactions include response transactions, snoop transactions, and victim transactions.

Abstract: A computer implemented system and method of performing parallel load operations during an extract, transform, load (ETL) operation. The system generates a single transaction having multiple processes, where each process loads into one target table. The processes are executed in parallel, and the system performs verification on the single transaction.

Abstract: A method of scheduling tasks within a GPU or other highly parallel processing unit is described which is both age-aware and wakeup event driven. Tasks which are received are added to an age-based task queue. Wakeup event bits for task types, or combinations of task types and data groups, are set in response to completion of a task dependency and these wakeup event bits are used to select an oldest task from the queue that satisfies predefined criteria.

Abstract: Systems and methods method for mapping between function calls and entities of the computer program. The method includes executing a computer program in a first computing environment; determining a first entity of the computer program to track; assigning an identifier to the first entity; determining the first entity has been accessed by at least one function call; and mapping the at least one function call with the identifier of the first entity; generating a cluster including the at least one function, wherein the cluster may be executed independently from the rest of the computer program.

Abstract: A computer-implemented method, computer program product and computing system for receiving a complex task; processing the complex task to define a plurality of discrete tasks each having a discrete goal; executing the plurality of discrete tasks on a plurality of machine-accessible public computing platforms; determining if any of the plurality of discrete tasks failed to achieve its discrete goal; and if a specific discrete task failed to achieve its discrete goal, defining a substitute discrete task having a substitute discrete goal.

Abstract: This technology relates to rasterizing and compositing vector graphics in parallel on a data-parallel computing device. For example, vector data of the vector graphics, may be loaded into local memory accessible by the one or more parallel processors. The vector data may include one or more paths comprised of one or more path segments of the vector graphics. The one or more parallel processors may rasterize the one or more path segments into respective rasters and assign each of the rasters into groups based on pixel coordinates of the respective rasters. Each group may have an associated key and the rasters within each group represent a portion of the same vector graphic. The rasters may be placed onto subpixels according to their respective pixel coordinates and rendered onto a display by the one or more parallel processors.

Abstract: A database system with a transactional commit protocol based on a safe conjunction of majorities is disclosed. In various embodiments, a directed acyclic graph comprising, for each of a plurality of database transactions, data identifying the transaction, data indicating one or more prior database transactions on which the database transaction depends, and data indicating whether the transaction has been committed is stored. A leading edge comprising a set of committed leaf nodes of the directed acyclic graph is determined. Data representing the leading edge is provided to a transaction coordinator configured to use the leading edge to determine based at least in part on the leading edge to commit a transaction.

Abstract: A method of processing media content in Moving Picture Experts Group (MPEG) Network Based Media Processing (NBMP) includes obtaining, from a function repository storing one or more functions for processing the media content, at least one among the one or more functions, each of the at least one among the one or more functions having a function descriptor indicating, for a respective one among the one or more functions, a maximum throughput, a minimum buffer size, a maximum size of metadata and a maximum frequency between two instances of the metadata, and obtaining a task for processing the media content, based on the obtained at least one among the one or more functions, the task having a task descriptor indicating, for the task, a maximum throughput, a minimum buffer size, a maximum size of metadata and a maximum frequency between two instances of the metadata.

Abstract: Methods, systems, and computer-readable media for resource usage restrictions in a time-series database are disclosed. Elements of a plurality of time series are stored into one or more storage tiers of a time-series database. The time series are associated with a plurality of clients of the time-series database. Execution of tasks is initiated using one or more resources of one or more hosts. The time-series elements represent inputs to the tasks. The tasks comprise a first task and a second task. A usage of the one or more resources by the first task is determined to violate one or more resource usage restrictions. Based at least in part on the usage, one or more actions are performed to modify the execution of the first task. The one or more actions increase an amount of the one or more resources available to the second task.

Abstract: A method for operating a controller, including: executing a first task-program in a first time pattern of first time-slots, performing a second task-program in a second time pattern of second time-slots, ascertaining a status variable, indicating whether a result of the first task-program is released, ascertaining the result of the first task-program in an instantaneous first time-slot and transmitted in this slot to a memory area assigned to the second task-program, the second task-program ascertains a second result as a function of the status variable value and the result of the first task-program, the status variable value is transmitted in the instantaneous time-slot to a status memory area assigned to the second task-program, the result of the first task-program and the status variables values are ascertained and transmitted after the beginning of execution of the first task-program and before another execution of the first task-program.

Abstract: Techniques for scheduling operations for a task graph on a processing device are provided. The techniques include receiving a task graph that specifies one or more passes, one or more resources, and one or more directed edges between passes and resources; identifying independent passes and dependent passes of the task graph; based on performance criteria of the processing device, scheduling commands to execute the passes; and transmitting scheduled commands to the processing device for execution as scheduled.

Abstract: A method, which may be performed by a computing system, involves determining that a plurality of notifications, including a first notification, is to be sent to a first client device, the first notification indicating a first task that is to be performed with respect to a resource accessible to the computing system; determining that a second task has a dependency relationship with the first task; determining at least one first parameter relating to the first task and at least one second parameter relating to the second task; determining, based at least in part on the at least one first parameter and the at least one second parameter, a first priority score corresponding to the first notification; and causing the plurality of notifications to be presented by the first client device in an order that is determined based at least in part on the first priority score.

Abstract: Techniques for process discovery and automatic generation of robotic scripts for distributed computing resources are disclosed. In one embodiment, at least one automatable process step associated with an activity performed while interacting with at least one application may be determined. The at least one automatable process step may be segregated into multiple tasks based on parallel executable tasks and sequentially executable tasks. Different types of distributed computing resources may be determined to execute the multiple tasks based on the segregation. A modified process flow corresponding to the at least one automatable process step may be automatically generated based on the segregated multiple tasks and the different types of the distributed computing resources. Further, a robotic script based on the modified flow of the at least one automatable process step may be automatically generated. The robotic script may be executed to perform the activity.

Abstract: An apparatus comprising: processing circuitry to process threads of data processing; and transactional memory support circuitry to support execution of a transaction within a thread processed by the processing circuitry. In response to a transactional compare-and-discard instruction executed within a given transaction, specifying a target address and a compare value, the processing circuitry loads a target data value from a memory location corresponding to the target address; sets at least one condition status indication depending on a result of comparing the target data value and the compare value; and discards the target data value without adding the target address to a working set of addresses tracked for the given transaction. This is useful for enabling thread level speculation to be implemented on a transactional memory architecture.

Abstract: Methods, systems, and computer-readable media are disclosed herein that utilizes historical changes made to files and methods in computer programming code to predict related files and methods that may be affected by current and/or future changes made to other files and methods. In aspects, when computer code for a particular method is going to be edited, other methods are identified that were changed in previous editing sessions that also included changes to the particular method. Using scoring techniques for the other methods, a recommendation is provided that details the relative strength of whether the other methods are predicted to be affected by any changes made to the computer code for the particular method that is edited.

Abstract: Techniques for process execution trend prediction and visualization are disclosed. The disclosed system receives a process execution request to be executed on a set of targets. The request may include request characteristics, such as a request type and computations to be performed during execution. The system analyzes the request characteristics to determine the computations to execute and for initiates request execution on the targets. Based on the analysis, the system generates predictions regarding the execution, including an estimated completion time. During execution, the system displays various attributes of the execution in a dynamically updating visualization. The system also provides real-time recommendations on how the process can be optimized, such as to reduce execution time and errors.

Abstract: A distributed data storage system can have a plurality of data storage devices connected to a host via a network controller. Receipt of a data access request from the host with the network controller can result in passing the data access request to a predetermined data storage device of the plurality of data storage devices with the network controller without processing the data access request. The data access request may then be satisfied with a device controller of the predetermined data storage device.

Abstract: A plurality of central processing units (CPUs) are allocated as a set of dedicated CPUs for processing tasks of an input/output (I/O) resource. In response to determining that a CPU utilization for the set of dedicated CPUs is less than a first predetermined threshold, at least one CPU of the set of dedicated CPUs is configured as a reserved CPU to execute tasks for one or more entities other than the I/O resource. In response to determining that a CPU utilization for the set of dedicated CPUs is greater than a second predetermined threshold, the reserved CPU is configured as a dedicated CPU to process tasks for the I/O resource.

Abstract: According to certain aspects of the disclosure, a computer-implemented method may be used for analytics integration into electronic applications. The method may include providing a request to a user for permission to access electronic data from a schedule application, and receiving from the user permission to access the electronic data. Additionally, the method may include parsing the electronic data, and displaying the electronic data in a second application. Additionally, the method may include creating data cards based on one or more entity terms of the electronic data, and displaying the data cards in the second application based on a user interaction with the one or more entity terms of the electronic data.

Abstract: Operational data in a distributed processing system is managed by monitoring a workload of the system to establish a current assessment of operational data movement between data sources and data targets, receiving historical information on previous data movement including previous instances of movement resulting in a compromise of one or more quality-of-service criteria, determining from the current assessment and historical information that upcoming operational data actions will not meet a particular quality-of-service criterion, and responsively applying a data management optimization infrastructure (data backplane services) adapted to advance the particular quality-of-service criterion according to definitions for the data sources and data targets. The operational outcome is predicted using a cognitive system trained with historical information including historical operational factors correlated with historical operational outcomes relative to the quality-of-service criteria.

Abstract: A low-latency cloud-scale computation environment includes a query language, optimization, scheduling, fault tolerance and fault recovery. An event model can be used to extend a declarative query language so that temporal analysis of event of an event stream can be performed. Extractors and outputters can be used to define and implement functions that extend the capabilities of the event-based query language. A script written in the extended query language can be translated into an optimal parallel continuous execution plan. Execution of the plan can be orchestrated by a streaming job manager which schedules vertices on available computing machines. The streaming job manager can monitor overall job execution. Fault tolerance can be provided by tracking execution progress and data dependencies in each vertex. In the event of a failure, another instance of the failed vertex can be scheduled. An optimal recovery point can be determined based on checkpoints and data dependencies.

Abstract: A computer implemented system and method of performing parallel load operations during an extract, transform, load (ETL) operation. The system generates a single transaction having multiple processes, where each process loads into one target table. The processes are executed in parallel, and the system performs verification on the single transaction.

Abstract: Embodiments of the present invention provide a system for facilitating reconciliation and correlation of work flows. The system is configured for identifying one or more applications associated with an operation, identifying relationships between each of the one or more applications, generating a matrix comprising the relationships between each of the one or more applications, receiving one or more entries from the one or more applications, storing the one or more entries in a ledger, and generating a single reconciliation file combining the one or more entries and the relationships.

Abstract: A method for initializing components of an electronic device includes receiving an input signal at an initialization block; after receiving the input signal, changing a state of a finite state machine (FSM) of the initialization block; sending an initialization signal from the initialization block to a component on a chip; after sending the initialization signal, changing the state of the FSM; receiving a return signal from the component with the initialization block; and after receiving the return signal, changing the state of the FSM.

Abstract: A method of displaying an interface for providing a social networking service (SNS) through an anonymous profile, performed by a user terminal, includes displaying a first list of at least one anonymous chatroom created by a user account for an instant messaging service (IMS) using a first region on a first page in an interface for the IMS, displaying a second list of at least one anonymous profile created to be interlinked with the user account using a first region on a second page in the interface for the IMS, and displaying, in response to an input of selecting any one anonymous profile in the second list, an interface for providing the SNS through the selected anonymous profile.

Abstract: A method of scheduling tasks within a GPU or other highly parallel processing unit is described which is both age-aware and wakeup event driven. Tasks which are received are added to an age-based task queue. Wakeup event bits for task types, or combinations of task types and data groups, are set in response to completion of a task dependency and these wakeup event bits are used to select an oldest task from the queue that satisfies predefined criteria.

Abstract: A method includes: receiving, by a computer device, resource request for a data integration job, wherein the resource request is received from a job executor module and defines processes of the data integration job; allocating, by the computer device, containers for the processes of the data integration job; launching, by the computer device, a respective wrapper script on each respective one of the containers after allocating the respective one of the containers; and transmitting, by the computer device and in response to the allocating, node details to the job executor module. In embodiments, the wrapper script running on the container is configured to repeatedly check a predefined location for process commands from a job executor. After the resource manager allocates all the containers for a data integration job according to a resource request, the job executor writes the process commands to the predefined location.

Abstract: Systems and methods are provided for performing temporal graph computing. One method may comprise receiving an input temporal graph that have a plurality of edges with each edge connecting from one vertex instance to another vertex instance, generating in-vertices and out-vertices for each vertex instance, merging the in-vertices and out-vertices into hub vertices for each vertex instance and generating a directed acyclic graph (DAG), receiving a minimum path problem, and scanning the DAG once to provide a solution to the minimum path problem. The merging of vertices and generation of the DAG may be performed by sorting all out-vertices using a 2-dimensional radix sort, generating a respective set of hub vertices for each vertex instance, relabeling the in-vertices and the out-vertices to their respective hub vertices for each vertex instance by a parallel binary search and updating edges affected by the relabeling, and assembling relabeled edges and vertices.

Abstract: In accordance with an embodiment, described herein is a system and method for dependency analysis for a calculation script in a multidimensional database computing environment. A multidimensional database cube aggregation can be represented as a lattice of blocks or cube, arranged according to a database outline (e.g., intra-dimensional or member hierarchy). When the multidimensional database system performs computations in parallel for a given calculation script, portions of the cube that can be computed concurrently are identified.

Abstract: An apparatus includes at least on processor to: parse a job flow definition for a job flow to identify an implicit expression of a data dependency arising from a data object output by a first task of the job flow and input to a second task thereof, wherein the first task is referred to as a data object required by the second as an input; in response to identifying the implicit expression, derive an order of performance of the tasks of the job flow that includes performing the first task before the second to ensure generation of the data object prior to performance of the second; for each task, retrieve a corresponding task routine; execute the task routines in an order that follows the order of performance of the tasks; and transmit, to the requesting device via the network, an indication of successful performance of the job flow.

Abstract: A first data storage device and a second data storage device can be connected to a first remote host and a second remote host via a server as part of a distributed data network. The server may assign the first data storage device to administer a first virtualization for a first logical volume of the first remote host. A device controller of the data storage device can execute an operating system and then load at least one operating component in the first remote host as directed by the first device controller. The device controller can subsequently perform a first software application in the first remote host as part of the first virtualization.

Abstract: A method, apparatus, computer-readable medium, and/or system may comprise a user device configured to receive, from a user, a selection of a plurality of dependent computing tasks for a first computing task. The user device may transmit, to a computing device, the selection of the plurality of dependent computing tasks for the first computing task. The system may comprise a computing device comprising a processor and memory storing computer-executable instructions that, when executed by the processor, cause the computing device to receive, from the user device, the selection of the plurality of dependent computing tasks for the first computing task. The computing device may store, at a task registry and in association with the first computing task, an indication of the plurality of dependent computing tasks. The computing device may cause transmission of the first computing task from the task registry to a task queue.

Abstract: Managing service container dependency is provided. A notification that a first service container is running on a host environment is received. It is determined whether the first service container is dependent on a second service container being up and running on the host environment. In response to determining that the first service container is dependent on a second service container being up and running on the host environment, it is determined whether the second service container is running on the host environment. In response to determining that the second service container is not running on the host environment, service requests from the first service container to the second service container are responded to using stub data that corresponds to the second service container.

Abstract: A computing node of a data storage system includes a data transform component. The data transform component identifies data that is maintained by the storage system and has a particular data structure. The data transform component may also perform analytics on the data based on the data structure. For example, different data sets that are dependent, e.g. related via association with the same application or type of application, or which are typically accessed in temporal proximity, can be discovered based on data structure and analytics. Data relationships may be used to prepare dependent data for access in advance of an IO associated with that dependent data.

Abstract: Systems, methods, and circuitries are provided for supporting multiple concurrent thread access to a storage array. In one example, a storage array includes a plurality of storage devices each divided into at least N subdivisions. A volume includes a set of subdivisions including a subdivision in each of M different storage devices. Memory management circuitry receives first data and second data for storing in the storage array and selects a first volume for storing the first data and a second volume for storing the second data. The second volume includes a different set of subdivisions than the first volume. The processor uses a first set of processor threads to process and store the first data in the first volume and uses a second set of processor threads to, concurrent with the processing and storing of the first data, process and store the second data in the second volume.

Abstract: An apparatus includes processor(s) to: receive a request to perform a job flow; retrieve a job flow definition from federated area(s); store, within a job queue, a job performance request message comprising the job flow definition; within a first performance container, execute a performance routine causing the processor(s) to, in response to the storage of the job performance request message within the job queue, derive an order of performance of tasks specifying a first task based on dependencies among the tasks, and store, within a task queue, a first task routine execution request message comprising an identifier associated with the first task; and within a first task container, in response to the storage of the first task routine execution request message within the task queue, use the identifier to retrieve a first task routine from the federated area(s), and execute the first task routine to perform the first task.

Abstract: Recommending applications based on call requests between applications is disclosed, including: receiving a plurality of sets of application call request recordings from respective ones of a plurality of client devices; using the plurality of sets of application call request recordings to generate association relationships between a first application and one or more other applications; determining a set of application recommendation information determined based at least in part on the association relationships between the first application and the one or more other applications; and sending the set of application recommendation information to a recipient client device.

Abstract: A system with improved power performance for tasks executed in parallel. A plurality of processing cores each to execute tasks. An inter-core messaging unit to conveys messages between the cores. A power management agent transitions a first core into a lower power state responsive to the first core waiting for a second core to complete a second task. In some embodiments long messages are subdivided to allow a receiving core to resume useful work sooner.

Abstract: Disclosed is an improved approach for implementing a system, method, and computer program product for integrating with a social media site, which can be used to create and configure a custom audience on the social media site.