Hybrid computing resource optimization model

Abstract

The invention relates to a hybrid computing resource optimization model. Network optimization for arranging computing subtasks in a hybrid computing environment is provided. The method includes receiving an input of a network of nodes and edges representing computational processes and composition information thereof, wherein the nodes are grouped depending on whether they use classical computing resources or quantum computing resources. The method generates workflow constraints, scheduling constraints, and computing resource allocation constraints. The method generates an objective function. And solving the optimization problem according to the objective function and all the constraints. The solution determines the best computational goal achieved, computational workflow through selection of nodes, computational job scheduling, and allocation of computational processes between classic and quantum computational resources. The computing workflow is then executed to achieve the best computing goal according to the computed job schedule and the allocation of the computing process between the classical computing resources and the quantum computing resources.

Description

Technical Field

[0001] This disclosure relates generally to computing systems, and more specifically to automated methods for determining the optimal arrangement of subprocesses in a computing task. Background Technology

[0002] Emerging technologies such as quantum computing, optical computing, neuromorphic computing, artificial intelligence and machine learning (AI / ML), general-purpose graphics processing units (GPGPUs), and high-performance computing (HPC) are maturing in various stages. These diverse technologies offer potential speedups and advantages for specific categories of problems compared to traditional computing methods. For example, quantum computing can achieve exponential speedups compared to classical HPC for calculating the ground-state energy of atoms and molecules and for integer factorization of large numbers. However, current hardware for some of these technologies is very limited; for instance, current quantum computers are classified as noisy medium-scale quantum (NISQ) devices, which are not only susceptible to severe noise problems but also have very limited quantum memory size. Therefore, determining how to compare classical and hybrid computing tasks, identifying performance bottlenecks, and finding the best way to utilize valuable computing resources are challenging problems that must be addressed during the adoption of these new technologies.

[0003] Therefore, it is desirable to have a method and apparatus that take into account at least some of the problems discussed above, as well as other possible problems. Summary of the Invention

[0004] An illustrative embodiment provides a computer-implemented network optimization method for deploying computational subtasks in a hybrid computing environment. The method includes receiving input from a network of nodes and edges representing computational processes and their compositional information, wherein nodes are grouped based on whether they use classical or quantum computing resources. The method generates workflow constraints, scheduling constraints, and computational resource allocation constraints. The method generates an objective function. An optimization problem is solved based on the objective function and all said constraints. The solution determines the best computational objective to be achieved, the computational workflow through node selection, computational job scheduling, and the allocation of computational processes between classical and quantum computing resources. Then, based on the computational job scheduling and the allocation of computational processes between classical and quantum computing resources, the computational workflow is executed to achieve the best computational objective.

[0005] Another illustrative embodiment provides a system for network optimization of deploying computational subtasks in a hybrid computing environment. The system includes a storage device for stored program instructions and one or more processors operatively connected to the storage device and configured to execute the program instructions, causing the system to: receive input from a network of nodes and edges representing computational processes and their compositional information, wherein nodes are grouped according to whether they use classical or quantum computing resources; generate workflow constraints; generate scheduling constraints; generate computational resource allocation constraints; generate an objective function; solve an optimization problem based on the objective function and all said constraints, wherein the solution determines the best computational objective to be achieved, a computational workflow through node selection, computational job scheduling, and the allocation of computational processes between classical and quantum computing resources; and execute the computational workflow to achieve the best computational objective based on the computational job scheduling and the allocation of computational processes between classical and quantum computing resources.

[0006] Another illustrative embodiment provides a computer program product for network optimization, used to deploy computational subtasks in a hybrid computing environment. The computer program product includes a computer-readable storage medium having program instructions embodied thereon to perform the following steps: receiving input from a network of nodes and edges representing computational processes and their composition information, wherein nodes are grouped according to whether they use classical or quantum computing resources; generating workflow constraints; generating scheduling constraints; generating computational resource allocation constraints; generating an objective function; solving an optimization problem based on the objective function and all said constraints, wherein the solution determines the best computational objective to be achieved, a computational workflow through node selection, computational job scheduling, and the allocation of computational processes between classical and quantum computing resources; and executing the computational workflow to achieve the best computational objective based on the computational job scheduling and the allocation of computational processes between classical and quantum computing resources.

[0007] Features and functions may be implemented independently in various embodiments of this disclosure, or may be combined in other embodiments, wherein further details can be seen with reference to the following description and accompanying drawings. Attached Figure Description

[0008] The appended claims set forth novel features of what are considered illustrative embodiments. However, the illustrative embodiments, their preferred modes of use, further objects and features will be best understood when read in conjunction with the accompanying drawings, by referring to the following detailed description of the illustrative embodiments of this disclosure, in which:

[0009] Figure 1 A block diagram illustrating a hybrid computing resource optimization system according to an illustrative embodiment is depicted;

[0010] Figure 2 A block diagram depicts a network optimization solution according to an illustrative embodiment;

[0011] Figure 3 A directed graph network depicting the computation process according to an illustrative embodiment;

[0012] Figure 4 A flowchart illustrating the process of network optimization for arranging computational subtasks in a hybrid computing environment is depicted; and

[0013] Figure 5 A block diagram of a data processing system according to an illustrative embodiment is depicted. Detailed Implementation

[0014] The illustrative embodiments recognize and consider one or more different considerations. The illustrative embodiments recognize and consider that a hybrid arrangement of classical and quantum computing resources has been identified as a means of utilizing the best capabilities of one resource relative to another.

[0015] The illustrative examples also recognize and take into account that current hybrid computing methods are hand-designed (typically by researchers exploring the use and adoption of new hardware or new computational subprocesses). Hybrid classical / quantum algorithms have been successfully proposed in the literature, but their discovery was carried out through a trial-and-error research process. As hardware continues to change and improve, the best available hybrid methods will also change.

[0016] The illustrative embodiments also recognize and consider that the identification of migration from one computational method to another often relies on rigorous benchmarking and comparison of different available methods. This does not provide a quantitative estimate of when or why a transition should occur, but only provides binary comparison results based on the benchmarks used.

[0017] The illustrative embodiments provide a method for determining the optimal arrangement of computational subprocesses to accomplish a larger computational task. The subprocesses may utilize different computational resources (such as classical and quantum computing), which can be combined into an optimal hybrid computational approach to solve the problem.

[0018] Given a set of potential subprocesses, the illustrative embodiments determine the optimal ordered arrangement of the steps of a computational process. Each subprocess is characterized by a set of required inputs and a set of produced outputs, as well as the required computation time, the error rate associated with the subprocess, and the amount of resources required. The illustrative embodiments can be applied to any hybrid computational process, such as hybrid classical / quantum computing, analog / digital computing, and can include subprocesses such as high-performance computing, FPGA, neuromorphic computing, DNA or chemical computing, optical computing, or any emerging form of computing technology.

[0019] Illustrative embodiments can also be used to investigate how the optimal solution changes with varying available resources or error rates. For example, the process can be run multiple times, with the amount of quantum resources allowed increasing with each run. This approach can reveal when transitioning from one form of computation to another might be most advantageous in minimizing computation time, minimizing errors associated with the overall computation, or maximizing resource utilization. For example, the process would help reveal when to migrate from classical or hybrid classical / quantum methods to fully quantum methods. Migration might be prompted by the fact that a computational speedup using the new method is available and / or the error rate associated with the new method is at least the same or better.

[0020] The illustrative embodiments also provide simultaneous computational task determination, resource allocation, and job scheduling for optimizing the problem.

[0021] Now go to Figure 1 The illustration depicts a block diagram of a hybrid computing resource optimization system according to an illustrative embodiment. The hybrid computing resource optimization system 100 includes an input set 102, a resource requirement calculator 114, and an output set 124.

[0022] Input set 102 includes a set of computational subtask nodes 104 representing potential components of the computation process. Each node within the computational subtask nodes 104 may include the resource requirements, time requirements, required input set, produced output set, and a representation of the error rate for the corresponding subtask. Input set 102 also includes computational objectives 106 for the computation process (such as, for example, minimizing computation time, minimizing required resources, maximizing accuracy / minimizing error, maximizing resource usage, or any combination thereof). Input set 102 may include optional user-provided constraints 108, such as, for example, that a particular node cannot exceed the specified maximum available resource usage, or that the total computational error cannot exceed the maximum acceptable error bound, etc. Input set 102 includes initial data input 110 and the expected final output 112 generated by the computation process based on the initial data input 100.

[0023] Resource requirement calculator 114 includes network generator 116, which generates a network representation of the provided computational subtask nodes 104 and their constituent information. Network edge generator 118 generates edge connections between nodes in the network generated by network generator 116, wherein if the output generated by node A can be used as the required input of node B, then two nodes A and B are connected by a directed edge from A to B.

[0024] Network optimization solution 120 solves the optimization according to computational objective 106 to determine the best path through the directed edge network. It identifies starting nodes (or sets of starting nodes), which are any nodes in the network whose required input is the same as the initial data input 110 provided in input set 102. It identifies ending nodes (or sets of ending nodes), which are any nodes in the network whose final output is the same as the expected final output 112 provided in input set 102. If there are multiple starting / ending nodes, multiple network optimization problems can be generated and solved sequentially or in parallel to determine the total number. Depending on any additional constraints 108 provided, the network problem (spanning all starting / ending nodes) is solved against computational objective 106. The solution can be implemented using different methods, such as, for example, shortest path, minimum cost, network flow, decision tree, or Steiner tree.

[0025] If more than one network instance is resolved, the targets are compared to determine the best solution.

[0026] Result extractor 122 receives the best network solution from 120. Result extractor 122 post-processes the data from the final best solution to produce output set 124.

[0027] Output set 124 includes the determined actual optimal path and nodes 126 traversed through subprocesses to achieve the computational process results and the determined target value 128. Output set 124 may also include estimated requirements 130, such as, for example, the expected total error in the solution, the total resources required, the total computation time to solve the problem, etc.

[0028] The hybrid computing resource optimization system 100 can be implemented using software, hardware, firmware, or a combination thereof. When using software, the operations performed by the hybrid computing resource optimization system 100 can be implemented in program code configured to run on hardware, such as a processor unit. When using firmware, the operations performed by the hybrid computing resource optimization system 100 can be implemented in program code and data and stored in persistent memory to run on a processor unit. When using hardware, the hardware can include circuitry that operates to perform the operations in the hybrid computing resource optimization system 100.

[0029] In the illustrative example, the hardware may take the form of at least one of the following: a circuit system, an integrated circuit, an application-specific integrated circuit (ASIC), a programmable logic device, or some other suitable type of hardware configured to perform multiple operations. In the case of a programmable logic device, the device may be configured to perform multiple operations. The device may be reconfigured later or may be permanently configured to perform multiple operations. Programmable logic devices include, for example, programmable logic arrays, programmable array logic, field-programmable logic arrays, field-programmable gate arrays, and other suitable hardware devices. Furthermore, the process may be implemented in organic components integrated with inorganic components and may consist entirely of organic components (excluding humans). For example, the process may be implemented as a circuit in an organic semiconductor.

[0030] These components for the hybrid computing resource optimization system 100 may reside in a computer system 150, which is a physical hardware system and includes one or more data processing systems. When more than one data processing system exists in the computer system 150, these data processing systems communicate with each other using a communication medium. The communication medium may be a network. The data processing systems may be selected from at least one of a computer, a server computer, a tablet computer, or some other suitable data processing system.

[0031] For example, the hybrid computing resource optimization system 100 can run on one or more processors 152 in a computer system 150. As used herein, a processor is a hardware device and consists of hardware circuitry (e.g., hardware circuitry on an integrated circuit that responds to and processes instructions and program code that operate the computer). When processor 152 executes instructions for a process, the one or more processors can be on the same computer or different computers in the computer system 150. In other words, the process can be distributed among processors 152 on the same or different computers in the computer system 150. Furthermore, the one or more processors 152 can be processors of the same or different types. For example, the one or more processors 152 can be selected from at least one of the following: a single-core processor, a dual-core processor, a multi-processor core, a general-purpose central processing unit (CPU), a graphics processing unit (GPU), a quantum processing unit (QPU), a tensor processing unit, a digital signal processor (DSP), a field-programmable gate array (FPGA), a neuromorphic processor, or some other type of processor.

[0032] Figure 2 A block diagram depicts a network optimization solution according to an illustrative embodiment. Figure 2 It shows Figure 1An example implementation of the network optimization solution 120 is provided, which takes a set of nodes and edges as input (these nodes and edges represent a graph network of data and computational task elements) and provides an optimally determined workflow (e.g., to minimize computation time, minimize result errors, etc.) selected by the available computational tasks relative to a user-selected objective.

[0033] Network optimization solution 120 uses an input set 202 including data nodes 204, compute nodes 206, data flow edges 208, and relations 210. Input set 202 represents the nodes and edges of a graphical representation of the computational task in question. These input elements are... Figure 1 The network generator 116 and network edge generator 118 are provided in the middle.

[0034] Data node 204 represents a discrete piece of data or a data element. Computation node 206 indicates a task that can be executed on a data node to produce a new data node. For example, a matrix and its inverse would be two different data nodes. An example of a computation node would be a matrix inversion algorithm, such as up-down (LU) decomposition or singular value decomposition (SVD) (this would be two different computation nodes). In the graph, LU and SVD would be computation nodes. The edges of these nodes are drawn from the matrix data elements to the matrix inverse data elements, indicating that these computation nodes consume the matrix and produce its inverse.

[0035] Relationship 210 defines the relationships between different data nodes 204 and computation nodes 206. The most common relationship is a data dependency. For example, a matrix inversion algorithm requires specific data elements. Another example is a data element produced by a computation process. Other such relationships may potentially exist, such as a computation process requiring at least one data element from a subset of data elements. Another example is the entity-relationship graph used to construct a graph network. Other possible relationships include data-data and computation-computation (e.g., a data element is a sub-component of a larger data element), etc. Some examples of relationships that can be accommodated in this process include:

[0036] • To continue this process, any n data elements in the set {d1,d2,d3,…} are required.

[0037] • To continue this process, all n data elements in the set {d1,d2,d3,…} are required.

[0038] • More complex nesting of sets composed of the two types of relationships mentioned above.

[0039] These relationships allow users to express more complex and nuanced data relationships, such as being able to specify various requirements for data inputs by computing nodes, such as "both x and y, but only one of a and b" (sort).

[0040] Given this information in input set 202, workflow 212 performs a series of linear steps to generate constraint equations and objective functions that include the integer optimization problem to be solved.

[0041] The Node / Edge Activation Constraint 214 generates two equations in the network for each node (each data element and each process task), which ensures that if a process task is selected as part of the workflow, the corollary input data elements and output data elements are also activated as part of the workflow.

[0042] Generate node / edge relationship constraint 216 to generate a constraint equation for each node in the network. This constraint equation ensures that the edge E connecting data elements v1 and v2 is activated in a consistent manner, meaning that if either data element v1 or v2 is activated, the corresponding edge is also activated.

[0043] The generation domain input constraints 218 generate a set of equations based on the required data elements specified by the user. These constraints ensure that the user's specifications for the available data elements are followed. For example, if the user specifies a data element v, representing a measurement known at the start of the process (based on system knowledge), this constraint ensures that the data element is true at the start of optimization. Alternatively, this can be achieved by assigning a corresponding data element variable x at the start of optimization. v =1 to achieve this goal.

[0044] The generation domain output constraint 220 generates a set of equations based on the desired data elements that the user wants the process to discover. These constraints ensure that the target end goal of the optimized workflow process achieves the target desired data elements that the user wants to know. For example, if the user wants the final matrix inverse or matrix product state, then at the end of the optimization process, the corresponding variable x... v It will be required to remain at 1. Alternatively, the variable x v =1 can be directly allocated at the start of optimization.

[0045] The generation of scheduling duration constraints 222 generates a set of constraint equations for each computing node in the network. These constraint equations represent the duration elapsed between the start and end of each process, matching the expected duration of the process plus possible scheduling delays. Scheduling delays can be zero (indicating no delay), but may be greater than zero if available resources are insufficient to accommodate an early start to the process. The scheduling delay time is included as a penalty in the objective function, which guides the optimizer to minimize these delays.

[0046] Duration (Δt) k This is a function of which machine is assigned to the process in question, i.e., the hardware quality of the assigned machine. For example, if a matrix inversion process requires n FLOPS (floating-point operations per second), then the duration (Δt) of the process... k This will depend on the assigned machine hardware, ((Δt) k = n / f, where f is the allocated FLOPS rate of the machine (related to the clock frequency). This may mean that supplementary equations are needed to accommodate FLOPS.

[0047] The generation of time discretization constraints 224 generates a set of equations for each node and each timestep. These equations ensure that events occurring over time throughout the workflow are queued and meaningful (e.g., the start time of a process matches the discretized time at the start of the process and correspondingly terminates with or without delay). The number of timesteps is a prerequisite for this approach, and the user specifies the time discretization model that shapes this value. One embodiment can represent time as a set of uniformly discretized time points, where time is determined by a fixed global timestep (Δt). G The instruction specifies that the time at any point in the workflow is given by t = i·(Δt). G This method can be adapted to different situations of interest. For example, adaptive non-uniform time discretization can be introduced.

[0048] The activity matrix constraint 226 generates equations for each node and for each available machine, which guarantees that the activities of the machines are matched in time with the start and end of the various processes assigned to the machines.

[0049] The scheduling and resource allocation, represented by the generation schedule duration constraint 222, the generation time discretization constraint 224, and the generation activity matrix constraint 226, can optionally be omitted from workflow 212. While including scheduling and resource allocation generally improves the quality of the solution and provides additional information, it may also increase the computational intensity of the optimization problem. Furthermore, there may be situations where the user does not yet need to know the actual scheduling and / or allocation of resources.

[0050] The resource matrix constraint 228 generates equations for each time step, each machine, and each resource type, ensuring that the resources consumed by various machines running at different times are within the range of resources available to the machines. For example, a quantum computer with 25 qubits cannot support the operation of a quantum circuit requiring 50 qubits. This constraint also limits the types (in the sense that a quantum computer cannot be selected to support GPU processes).

[0051] The generation of time definition constraint 230 relates to the generation of time discretization constraint 224, and generates an equation representing the passage of time. As mentioned above, time discretization can be uniform, but any type of time discretization can be supported.

[0052] Time discretization scheme 238 supports both generating time discretization constraints 224 and generating time definition constraints 230. Time discretization scheme 238 represents a method for representing the elapsed time during a workflow. In addition to uniform time discretization, the illustrative embodiments can also be adapted to any type of representation, such as, for example, adaptive schemes, non-uniform representations, functional or pre-scheduled forms, etc.

[0053] The total cost constraint 232 generates a set of equations that represent the cost of each resource used by each process. As used herein, “cost” refers to general cost, not a specific monetary value (although it may also include monetary costs). Costs may be amounts of time, amounts of power consumed, amounts of error caused, or combinations of one or more of these factors. These equations capture the effects of accumulated costs in the selected workflow.

[0054] Users can also include any additional constraints they wish to impose on costs. For example, they can specify a blanket statement that the power required by the workflow cannot exceed a certain wattage (which may represent facility power limitations). Each of these constraints will be added according to the user's specifications.

[0055] Typically, but not necessarily, these costs increase across the selected workflow process. However, costs can also multiply across the selected workflow process. Examples of increased costs would be the total duration of computing something (each process adds a fixed amount of time before it can reach that data element), or the monetary cost of using processor resources (adding more processors may cause the cost per processor to increase linearly). Examples of multiplied costs would be errors (e.g., the probability of failure is the product of all gate operations in a circuit).

[0056] Generate the objective function 234, which is an expression to be minimized or maximized by the optimizer. This expression might be a "computation completion time," i.e., the total wall time elapsed for solving the problem using the fastest possible workflow approach. Wall time refers to the difference between the system clock value before a process begins and after it has completed. This contrasts with other time metrics (such as CPU time), which only measure the actual activity time of the process on the processor (typically a much smaller number than wall time).

[0057] The expression can also be "total runtime" or equivalently "CPU time," which differs from makespan in that runtime considers the time spent on each resource, rather than just the wall time the process traverses. For example, if a process takes one (1) second and is parallelized on four (4) processors, reducing it to complete in just 1 / 4 second, the makespan will be 1 / 4 second, but the runtime will be [missing value]. Seconds. Runtime is more useful for estimating the cost of parallelizing computation processes (estimated cost of using high-performance computing clusters, for example, based on CPU time rather than wall time).

[0058] Solving optimization problem 236 can be performed by any algorithm or software that computes a solution to the system of equations generated above for the constraints, variables, and expressions. This could be a mixed-integer optimizer using branch-and-bound, branch-and-cut, branch-and-price, etc., or a heuristic or metaheuristic algorithm, such as simulated annealing, particle swarm optimization, genetic algorithms, etc., to iteratively determine a numerical solution for the resulting combination of equations. The illustrative examples are independent of the method chosen for this step. To solve the optimization problem, the algorithm performs iterative computations that improve the solution as the algorithm explores the solution space. The problem is considered "solved" when a stopping criterion has been met on one of these iterations. This criterion could be a convergence check in the solution, a fixed number of iterations or a fixed amount of time elapsed, the size of the solution space explored, the best possible objective value achieved for the found solution, etc. Possible stopping criteria depend on the algorithm in question.

[0059] After solving the optimization problem, the output set 240 includes the selected best computational workflow 242, the best achieved objective evaluation 244, computational job scheduling 246, and resource allocation 248, which are determined by... Figure 1The results extractor 122 extracts the solution and transforms it back into the form of a workflow process, and also extracts and transforms the time schedules of various machines (which may include generating batch scheduling jobs for large heterogeneous computing systems), and also records and displays resource usage (e.g., as a Gantt chart output).

[0060] The general computation process can be decomposed into a series of subtasks, T i ={R i ,t i ,S i U i E i}, where a single subtask T i It consists of the following parts:

[0061] • The required set of resources, R i

[0062] • Time quantity or computational intensity, t i This could be a function of the allocated hardware (i.e., FLOPS).

[0063] • The required set of inputs, S i

[0064] • A set of outputs, U i

[0065] • Potential error representation associated with the output, E i

[0066] Typically, there is a known set of initial data G, some expected final product H, and a selection order of processes to complete the subtasks. Resources R i and time or intensity t i It can be a scalar (such as subtask T) i The required number of bits / qubits and / or processors, or it could be more functional (such as two functions R). i (n) and t i (n), which describes the scaling of resources and time required as the problem size n increases.

[0067] Error E associated with the output i It can be similarly zero (a scalar value for an exact process) or a Gaussian distribution, can be a noisy model, or can be the problem size or problem complexity E. i A function of (n).

[0068] The illustrative embodiments optimize the ordering of computational subtasks to complete the entire computation process while using minimal computation time, resources, or final output error (or some combination thereof). Furthermore, constraints may exist on the problem, such as the ordering of subtasks to create appropriate outputs that become inputs to subsequent subtasks. Additional constraints may exist for the application, such as available resource limits or maximum acceptable error limits for specific subtasks. Error propagation from one subtask to the next does not need to be limited to a linear sum but can include more precise nonlinear propagation.

[0069] The illustrative embodiments can be applied to example problems of interest such as calculating corrosion rates and modeling microscale interactions of aerospace materials in harsh environments, and explore the use of classical and quantum computing resources to solve these problems.

[0070] Figure 3 A directed graph network is depicted, illustrating the computational process according to an illustrative embodiment. The directed graph network 300 can be constructed from... Figure 1 Examples of networks created by network generator 116 and network edge generator 118.

[0071] The computation process can be represented as a graph, where nodes represent subtasks executed using a specific process. Each node n in the graph... i T represents the potential computational subtask. i This can be performed during the computation process from the initial starting dataset G to the desired final dataset H. In this example, the computational subtask nodes include classical nodes C1, C2, C3, C4, C5, C6 and quantum nodes Q1, Q2, Q3, Q4. Classical node C i This indicates any classic program that can be used. Classic method C i This may include methods such as Discrete Fourier Transform (DFT), Dynamical Monte Carlo (kMC), and any preprocessing or post-processing steps that can be performed. Quantum node Q i It represents any quantum process that can run.

[0072] The illustrative embodiment attempts to find any node from which the input is required to be equal to the initial starting data input S0 = G to produce the final desired output data U. N = The "shortest path" (lowest cost) on a directed graph network 200 with any node of H. Additional constraints ensure that edges between nodes are allowed only if the output of one node can feed into the input of the next node.

[0073] This process can be extended beyond using only classical and quantum resources to include manual or laboratory processes, or other emerging forms of computing such as analog / digital hybrid computing, DNA computing, optical computing, neuromorphic computing, etc. Laboratory measurement processes that can provide some of the desired values ​​for the overall process can also be added to the graph if reasonable estimates of equivalent resources / time / error are available. Additional constraints can be added to the problem formulation to represent task parallelization using the partitioning of output and input data at the edges of the graph. These formulations can be used to minimize total computation time, minimize error propagation, or maximize the best use of available resources.

[0074] One possible formulation for application to directed graph networks 300 includes an optimization method to minimize the total computation time while ensuring that all resources required by the problem are available, and also ensuring that the error of the final computation result is within an acceptable maximum error bound. In this formulation, given initial data G and the desired final output H, the optimization process minimizes the total required time:

[0075]

[0076] The total error constrained by the entire process must be less than the maximum acceptable error E. max :

[0077]

[0078] The resources used at each node must be available:

[0079]

[0080] The first process must use the initial data:

[0081] S0 = G

[0082] And the final data generated must be the expected final output:

[0083] U N =H

[0084] Alternatively, as long as the resources required by each computational subtask are available and the total computation time is below an acceptable limit, optimizing the workflow process can solve the problem to achieve the most accurate possible result data elements. Any restatement can be created based on a combination of constraints on error rate, resources, and / or time. Therefore, given the initial data G and the desired final output H, the optimization time will minimize the total propagation error of the final result:

[0085]

[0086] Constrained by the total computation time being less than the specified upper limit t max :

[0087] ∑ i t i <t max

[0088] The resources used at each node must be available:

[0089]

[0090] The first process must use the initial data:

[0091] S0 = G

[0092] And the final data generated must be the expected final output:

[0093] U N =H

[0094] Furthermore, specific formulations of the network problem can be rerun with different parameters, such as changing the maximum resources available for a particular type of hardware, or altering the error rate associated with a particular computational subtask available on the graph, to better understand how the optimal choice of the algorithmic stack will shift from one hardware to another based on error. In this way, running the optimization problem multiple times with different parameters helps determine the optimal transition between classical and quantum hardware types.

[0095] Figure 4 A flowchart is depicted illustrating the process for network optimization in arranging computational subtasks within a hybrid computing environment. Process flow 400 can... Figure 1 The hybrid computing resource optimization system 100 shown includes Figure 2 The network optimization solution 120 shown is implemented.

[0096] Process 400 begins by receiving input from the network of nodes and edges representing computational processes and their constituent information, wherein nodes are grouped according to whether they use classical or quantum computing resources (operation 402).

[0097] Then, process 400 generates workflow constraints (operation 404). Workflow constraints include node and edge activation constraints, node and edge relationship constraints, domain input constraints, domain output constraints, resource constraints, time definition constraints, and total cost constraints.

[0098] In response to the selection of processes as part of the computational workflow, node and edge activation constraints ensure that derived input and output data elements are also activated as part of the workflow. Node and edge constraints may also include node and edge relationship constraints, which ensure that in response to the activation of one of a pair of nodes, the edge connecting that pair of nodes is activated.

[0099] In response to the activation of one of a pair of nodes, the node and edge relationship constraint ensures that the edge connecting the pair of nodes is activated.

[0100] Domain input constraints and domain output constraints ensure adherence to the user-defined specifications for available data elements and ensure that the ultimate goal of the computational workflow is to achieve the user-specified target data elements. Alternatively, domain input constraints and domain output constraints assign corresponding data element variables at the start of optimization.

[0101] Resource constraints ensure that the resources available for classical and quantum computing running on a machine are within the range of resources available on the machine.

[0102] The total cost constraint covers at least one of the following: monetary cost, time amount, power consumed, and error incurred.

[0103] Procedure 400 generates scheduling constraints (operation 406). Scheduling constraints may include scheduling duration constraints and time discretization constraints.

[0104] Process 400 generates computational resource allocation constraints (operation 408). Computational resource allocation constraints include activity constraints, which ensure that the activities of machines running classical and quantum computing resources are matched in time with the start and end of computational processes allocated to these machines.

[0105] Process 400 generates the objective function (operation 410), and then solves the optimization problem based on the objective function and all the constraints described above (operation 412). This solution determines the best computational objective achieved, the computational workflow through node selection, computational job scheduling, and the allocation of computational processes between classical and quantum computing resources.

[0106] Process 400 executes the computational workflow based on the computational job scheduling and the allocation of computational processes between classical and quantum computing resources to achieve the best computational objective (operation 414). Then, process 400 terminates.

[0107] Now go to Figure 5 A block diagram of a data processing system is depicted according to an illustrative embodiment. The data processing system may be... Figure 1An example of a computer system 150 is provided. In this illustrative example, the data processing system 500 includes a communication framework 502 that provides communication between a processor unit 504, a memory 506, a persistent storage device 508, a communication unit 510, an input / output unit 512, and a display 514. In this example, the communication framework 502 may take the form of a bus system.

[0108] Processor unit 504 is used to execute instructions for software that can be loaded into memory 506. Depending on the specific implementation, processor unit 504 may be multiple processors, a multiprocessor core, or some other type of processor. In one embodiment, processor unit 504 includes one or more conventional general-purpose central processing units (CPUs). Processor unit 504 can send instructions to and from digital signal processor (DSP) 528. DSP 528 then sends analog or mixed signals to and from quantum hardware 530.

[0109] Quantum hardware 530 may include qubit-based quantum circuits. Qubits are traditionally used to simulate either a 1 or 0 state, or a superposition of 1 and 0 states. However, when measured, a qubit may be in an infinite number of states, depending on the quantum state of the qubit immediately preceding the measurement when using Bloch sphere representation. Quantum circuits may include multiple reversible quantum gates, where the computation is logically reversible.

[0110] Memory 506 and persistent storage device 508 are examples of storage device 516. A storage device is any hardware capable of storing information (such as, but not limited to, at least one of, data, program code in functional form, or other suitable information) on a temporary, permanent, or both temporary and permanent basis. In these illustrative examples, storage device 516 may also be referred to as a computer-readable storage device. In these examples, memory 506 may be, for example, random access memory or any other suitable volatile or non-volatile storage device. Persistent storage device 508 may take various forms depending on the specific implementation.

[0111] For example, persistent storage device 508 may include one or more components or devices. For example, persistent storage device 508 may be a hard disk drive, flash memory, rewritable optical disk, rewritable magnetic tape, or some combination thereof. The media used in persistent storage device 508 may also be removable. For example, a removable hard disk drive may be used in persistent storage device 508. In these illustrative examples, communication unit 510 provides communication with other data processing systems or devices. In these illustrative examples, communication unit 510 is a network interface card.

[0112] The input / output unit 512 allows data input and output to other devices that can be connected to the data processing system 500. For example, the input / output unit 512 can provide a connection for user input via at least one of a keyboard, mouse, or some other suitable input device. Furthermore, the input / output unit 512 can send output to a printer. The display 514 provides a mechanism for displaying information to the user.

[0113] Instructions for at least one of the operating system, application, or program may reside in storage device 516, which communicates with processor unit 504 via communication frame 502. Processes in different embodiments may be executed by processor unit 504 using computer-implemented instructions, which may reside in memory (e.g., memory 506).

[0114] These instructions are referred to as program code, computer-usable program code, or computer-readable program code, which can be read and executed by the processor in processor unit 504. The program code in different embodiments may be embodied on different physical or computer-readable storage media (e.g., memory 506 or persistent storage device 508).

[0115] Program code 518 is functionally located on a computer-readable medium 520, which is selectively removable and can be loaded or transferred to a data processing system 500 for execution by a processor unit 504. In these illustrative examples, program code 518 and computer-readable medium 520 form a computer program product 522. Computer program product 522 may be used as a reference frame for aligning an augmented reality (AR) display. In one example, computer-readable medium 520 may be a computer-readable storage medium 524 or a computer-readable signal medium 526.

[0116] In these illustrative examples, computer-readable storage medium 524 is a physical or tangible storage device for storing program code 518, rather than a medium for propagating or transmitting program code 518. Alternatively, program code 518 may be transmitted to data processing system 500 using computer-readable signal medium 526.

[0117] The computer-readable signal medium 526 may be, for example, a propagated data signal containing program code 518. For example, the computer-readable signal medium 526 may be at least one of electromagnetic signals, optical signals, or any other suitable type of signal. These signals can be transmitted via at least one of a communication link (e.g., a wireless communication link, fiber optic cable, coaxial cable, wire, or any other suitable type of communication link).

[0118] The different components shown for data processing system 500 do not imply an architectural limitation on how different embodiments can be implemented. Different illustrative embodiments may be implemented in a data processing system that includes components other than those shown for data processing system 500 or components that replace those shown for data processing system 500. Figure 5 Other components shown may differ from the illustrative example illustrated. Different embodiments may be implemented using any hardware device or system capable of running program code 518.

[0119] As used herein, "connected to" a first component means that the first component can be directly or indirectly connected to the second component. In other words, there may be additional components between the first and second components. When one or more additional components exist between the two components, the first component is considered to be indirectly connected to the second component. When the first component is directly connected to the second component, there are no additional components between the two components.

[0120] As used in this article, the phrase “a number” means one or more. When used with a list of items, the phrase “at least one of…” means that different combinations of one or more of the listed items can be used, and it is possible that only one of each item in the list is required. In other words, “at least one of…” means that any combination of items and the number of items from the list can be used, but not all items in the list are required. Items can be specific objects, things, or categories.

[0121] For example, but not limited to, "at least one of Item A, Item B, or Item C" may include Item A, Item B, or Item C. This example may also include Item A, Item B, and Item C, or Item B and Item C. Of course, any combination of these items is possible. In some illustrative examples, "at least one of..." could be, for example, but not limited to, two of Item A; one of Item B; and ten of Item C; four of Item B and seven of Item C; or other suitable combinations.

[0122] The flowcharts and block diagrams in the different depicted embodiments illustrate the architecture, functionality, and operation of some possible implementations of the apparatus and methods in the illustrative embodiments. In this regard, each block in a flowchart or block diagram may represent at least one of a module, segment, function, or part of an operation or step. For example, one or more blocks may be implemented as program code.

[0123] In some alternative implementations of the illustrative embodiments, one or more functions noted in a block may not appear in the order shown in the figures. For example, in some cases, two blocks shown consecutively may be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order, depending on the functions involved. Furthermore, additional blocks may be added besides those shown in the flowcharts or block diagrams.

[0124] This application also includes embodiments pursuant to the following provisions:

[0125] Clause 1. A system for network optimization of deploying computational subtasks in a hybrid computing environment, the system comprising:

[0126] Storage device (516), which stores program instructions;

[0127] One or more processors (504, 528) are operatively connected to the storage device and configured to execute the program instructions to cause the system to perform the following operations:

[0128] Receive input (402) of a network of nodes and edges representing computational processes and their constituent information, wherein the nodes are grouped according to whether they use classical or quantum computing resources;

[0129] Generate workflow constraints (404);

[0130] Generate scheduling constraints (406);

[0131] Generate computational resource allocation constraints (408);

[0132] Generate the objective function (410);

[0133] Solve the optimization problem (412) according to the objective function and all the constraints, wherein the solution determines the best computational objective achieved, the computational workflow through the selection of the nodes, the computational job scheduling, and the allocation of the computational process between the classical and quantum computing resources; and

[0134] Based on the calculated job schedule and the allocation of computation processes between the classical computing resources and quantum computing resources, the computation workflow (414) is executed to achieve the optimal computational objective.

[0135] Clause 2. The system according to Clause 1, wherein the workflow constraints include: node and edge activation constraints (214); node and edge relationship constraints (216); domain input constraints (218); domain output constraints (220); resource constraints (226); time definition constraints (230); and total cost constraints (232).

[0136] Clause 3. The system according to Clause 2, wherein the node and edge activation constraints, in response to the selection of a process as part of the computation workflow, ensure that derived input data elements and output data elements are also activated as part of the workflow.

[0137] Clause 4. The system according to Clause 2, wherein the node and edge relationship constraint, in response to the activation of one of a pair of nodes, ensures that the edge connecting the pair of nodes is activated.

[0138] Clause 5. The system according to Clause 2, wherein the domain input constraints and domain output constraints ensure compliance with the user specifications of the available data elements, and the ultimate goal of the computational workflow is to achieve the target data elements specified by the user.

[0139] Clause 6. The system according to Clause 2, wherein the domain input constraints and domain output constraints are assigned corresponding data element variables at the start of optimization.

[0140] Clause 7. The system according to Clause 2, wherein the resource constraints ensure that classical computing resources and quantum computing resources running on the machine are within the resources provided on the machine.

[0141] Clause 8. The system described in Clause 2, wherein the cost includes at least one of the following: monetary cost; time amount; power consumed; or error caused.

[0142] Clause 9. The system according to Clause 1, wherein the scheduling constraints include: a scheduling duration constraint (222); and a time discretization constraint (224).

[0143] Clause 10. The system according to Clause 1, wherein the computing resource allocation constraints include an activity constraint (226) that ensures that the activities of the machines running the classical and quantum computing resources are time-matched with the start and end of the computing processes allocated to those machines.

[0144] Clause 11. A computer program product for network optimization of arranging computational subtasks in a hybrid computing environment, the computer program product comprising:

[0145] A computer-readable storage medium (524) having program instructions thereon for performing the following steps:

[0146] Receive input (402) of a network of nodes and edges representing computational processes and their constituent information, wherein the nodes are grouped according to whether they use classical or quantum computing resources;

[0147] Generate workflow constraints (404);

[0148] Generate scheduling constraints (406);

[0149] Generate computational resource allocation constraints (408);

[0150] Generate the objective function (410);

[0151] Solve the optimization problem (412) according to the objective function and all the constraints, wherein the solution determines the best computational objective achieved, the computational workflow through the selection of the nodes, the computational job scheduling, and the allocation of the computational process between the classical and quantum computing resources; and

[0152] Based on the calculated job schedule and the allocation of computation processes between the classical computing resources and quantum computing resources, the computation workflow (414) is executed to achieve the optimal computational objective.

[0153] The descriptions of various illustrative embodiments have been presented for purposes of illustration and description and are not intended to be exhaustive or limited to the embodiments of the disclosed forms. Many modifications and variations will be apparent to those skilled in the art. Furthermore, different illustrative embodiments may provide different features compared to other illustrative embodiments. One or more embodiments have been selected and described in order to best explain the principles of the embodiments, their practical application, and to enable those skilled in the art to understand the disclosure of various embodiments with various modifications suitable for the intended particular purpose.

Claims

1. A computer-implemented method for network optimization of deploying computational subtasks in a hybrid computing environment, the method comprising: Receive input (402) of a network of nodes and edges representing computational processes and their constituent information, wherein the nodes are grouped according to whether they use classical or quantum computing resources; Generate workflow constraints (404); Generate scheduling constraints (406); Generate computational resource allocation constraints (408); Generate the objective function (410); The optimization problem (412) is solved according to the objective function and all the constraints, wherein the solution determines the best computational objective achieved, the computational workflow through the selection of the nodes, the computational job scheduling, and the allocation of the computational process between the classical computing resources and the quantum computing resources; and Based on the calculated job schedule and the allocation of computation processes between the classical computing resources and quantum computing resources, the computation workflow (414) is executed to achieve the optimal computational objective.

2. The method according to claim 1, wherein the workflow constraints include: Node and edge activation constraints (214); Node and edge relationship constraints (216); Domain input constraints (218); Domain output constraint (220); Resource constraints (226); Time definition constraint (230); and Total cost constraint (232).

3. The method according to claim 2, wherein, The node and edge activation constraints, in response to the selection of processes that are part of the computation workflow, ensure that derived input and output data elements are also activated as part of the workflow.

4. The method according to claim 2, wherein, The node and edge relationship constraints respond to the activation of one of a pair of nodes, ensuring that the edge connecting the pair of nodes is activated.

5. The method of claim 2, wherein the domain input constraints and domain output constraints ensure compliance with the user specifications of the available data elements, and the ultimate goal of the computational workflow is to achieve the target data elements specified by the user.

6. The method according to claim 2, wherein the domain input constraints and domain output constraints are assigned corresponding data element variables at the start of optimization.

7. The method of claim 2, wherein the resource constraint ensures that the classical computing resources and quantum computing resources running on the machine are within the resources provided on the machine.

8. The method of claim 2, wherein the cost includes at least one of the following: Monetary costs; Time quantity; Power consumed; or The resulting error.

9. The method according to claim 1, wherein the scheduling constraints include: Scheduling duration constraint (222); and Time discretization constraint (224).

10. The method of claim 1, wherein the computing resource allocation constraint includes an activity constraint (226) that ensures that the activities of the machines running the classical and quantum computing resources are time-matched with the start and end of the computing processes allocated to those machines.

Images