WO2021228483A1 - Vorrichtung und verfahren zum erzeugen von instruktionen für eine recheneinrichtung zur ausführung einer rechenvorschrift - Google Patents

Vorrichtung und verfahren zum erzeugen von instruktionen für eine recheneinrichtung zur ausführung einer rechenvorschrift Download PDF

Info

Publication number
WO2021228483A1
WO2021228483A1 PCT/EP2021/059682 EP2021059682W WO2021228483A1 WO 2021228483 A1 WO2021228483 A1 WO 2021228483A1 EP 2021059682 W EP2021059682 W EP 2021059682W WO 2021228483 A1 WO2021228483 A1 WO 2021228483A1
Authority
WO
WIPO (PCT)
Prior art keywords
node
graph
defines
nodes
determined
Prior art date
Application number
PCT/EP2021/059682
Other languages
English (en)
French (fr)
Inventor
Dennis Sebastian RIEBER
Original Assignee
Robert Bosch Gmbh
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Robert Bosch Gmbh filed Critical Robert Bosch Gmbh
Priority to US17/920,862 priority Critical patent/US20230244745A1/en
Priority to CN202180034739.2A priority patent/CN115485663A/zh
Publication of WO2021228483A1 publication Critical patent/WO2021228483A1/de

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
    • G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
    • G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
    • G06F9/5038—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G06F17/11—Complex mathematical operations for solving equations, e.g. nonlinear equations, general mathematical optimization problems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F18/00—Pattern recognition
    • G06F18/10—Pre-processing; Data cleansing
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G06F8/34—Graphical or visual programming
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
    • G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
    • G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
    • G06F9/5044—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering hardware capabilities
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
    • G06V10/00—Arrangements for image or video recognition or understanding
    • G06V10/70—Arrangements for image or video recognition or understanding using pattern recognition or machine learning
    • G06V10/74—Image or video pattern matching; Proximity measures in feature spaces
    • G06V10/75—Organisation of the matching processes, e.g. simultaneous or sequential comparisons of image or video features; Coarse-fine approaches, e.g. multi-scale approaches; using context analysis; Selection of dictionaries
    • G06V10/757—Matching configurations of points or features

Definitions

  • Computing device for executing a computation rule
  • the invention is based on a device and a method for generating instructions for a computing device for executing a computation rule.
  • TVM End-to-End Optimization Stack for Deep Learning. CoRR abs / 1802.04799 (2016).
  • arXiv: 1802.04799 http://arxiv.org/abs/1802.04799 discloses a tool called TVM for selecting instructions for electronic circuits made for specific mathematical calculations. These are known as accelerators or hardware accelerators and are used, for example, for calculations in artificial neural networks.
  • a computer-implemented method for generating instructions for a computing device for executing a calculation rule provides that a directed first graph with nodes and edges is provided, which defines first instructions for the computing device for executing the calculation rule, with at least a first part in the first graph a first structure is searched, with a second part with a second structure being determined depending on the at least one first part, with a directed second graph with nodes and edges being determined depending on the first graph, with the first part through the second part in the second graph is replaced, the second graph defining second instructions for the computing device for executing the arithmetic rule, a pattern being provided for at least part of a graph, the nodes and edges of which are defined by instructions that can be executed by the computing device, the I Instructions for the computing device are generated either as a function of the first graph or as a function of the second graph, and the first graph or the second graph for generating instructions for the computing device is selected as a function of the pattern.
  • the first graph can be a directed acyclic connected graph.
  • subgraphs are found that correspond to a search pattern. For these subgraphs, new subgraphs are generated which define instructions with which the same partial result can be completely determined.
  • a second graph is generated with the new subgraphs.
  • Different computing devices can determine different partial results with different specialized hardware at different speeds or with different precision.
  • One of the graphs with which the instructions are generated is selected for a specific hardware.
  • the pattern defines the instructions that are particularly suitable for the particular hardware. In this way, the instructions that are particularly suitable for this hardware can be generated.
  • the directed edges can be used to represent data dependencies that are taken into account when selecting the graph.
  • the nodes can define operations or operands for executing the arithmetic rule, the edges defining a sequence of the application of operations for executing the arithmetic rule.
  • a graph is provided that includes a node that defines an iterator for an operation for executing the arithmetic rule, with a length of a path in the graph between a node that uses the iterator and the Node defining the iterator is determined, wherein in the node using the iterator a reference to the node defining the iterator is replaced by an indication that includes the length of the path, and the directed first graph is dependent on the node spanning the length of the path is determined.
  • the length of the path is defined. Starting from the node that defines the iterator, the node that uses the iterator can be reached in the first graph by determining its parent node for a child node until the length of the path is reached.
  • the first structure can define a first subgraph comprising a plurality of nodes and edges which define at least one operation in a first order for at least two operands, the second structure defining a second subgraph which is defined by the nodes of the first subgraph, wherein the edges of the second subgraph for the at least two operands O define at least one operation in a second order, wherein the at least one operation defines an element-wise operation.
  • the first structure can be defined by a first character string defining a path in the first graph, the second structure being defined by a second character string defining a path in the second graph. This allows pattern matches to be made through string comparisons.
  • the first character string and / or the second character string may comprise an ordered list of labels for nodes in the path that defines the path. This makes paths particularly easy to find in the string comparison.
  • the first structure can define a first subgraph comprising a plurality of nodes and edges which define a first arrangement in a memory of the computing device for at least two dimensions of an operand, the second structure defining a second subgraph which is defined by the nodes of the first subgraph is defined, the edges of the second subgraph defining a second arrangement in the memory for the at least two dimensions of the operand.
  • the first arrangement may define a first tensor for data, the second arrangement defining a second tensor for the data, the second tensor being defined by the transposed first tensor.
  • the first arrangement can comprise more dimensions than the second arrangement, the second arrangement being determined by linearizing a plurality of dimensions of the first arrangement.
  • the first arrangement can comprise fewer dimensions than the second arrangement, the second arrangement being determined by replicating at least one dimension of a plurality of dimensions of the first arrangement or by adding a dimension filled with at least one value, in particular with at least one zero.
  • the data can be defined by an input for the arithmetic rule or by a partial result of the arithmetic rule.
  • the first structure can define a first subgraph comprising a first node at which no edge begins, the first node defining a first memory area for the computing device in at least two dimensions, the first structure comprising a second node having an operation for Values in the first memory area defined, with a second memory area for the computing device being defined in at least one of the dimensions of the first memory area, the second structure defining a second subgraph in which the first node of the first subgraph is replaced by a third node that represents the second memory area defined, the second structure for at least one dimension of the first memory area that is missing in the second memory area, defines a program loop which defines a repeated execution of the operation on the second operand over this dimension.
  • Executable instructions can be specified, determined or received by the computing device, the pattern being determined as a function of the executable instructions.
  • a data structure for a node of the first graph is preferably determined, which comprises a data field that defines an operation to be applied to other nodes, a data structure for a node of the second graph with the same data structure is determined, wherein a data field defining a node to which the operation is to be applied is replaced by a data field in which another node is defined to which the operation is to be applied, the other node either in another data field of the Data structure for the node is defined, or wherein the other node is defined in a data field of a data structure of a further node to which a data field from the data structure of the node of the first graph refers.
  • a data structure for a node of the first graph is preferably determined which comprises a data field which defines a list with other nodes, a data structure being determined for a node of the second graph with the same data structure, wherein the data field that defines the list is replaced by a data field in which a first entry from the list is swapped with a second entry from the list.
  • At least one node is preferably determined which defines a program loop for determining a result, the node being assigned a parameter that characterizes a memory tile in the memory, a first program loop and a second program loop being determined depending on the parameter, the first program loop at least an instruction for determining the result and an instruction for calling the second program loop with which a partial result can be determined. This enables the program loops to be segmented if the instructions are smaller than the dimensions of the arithmetic rule.
  • a device for generating instructions for a computing device for executing a calculation rule is designed to execute the method.
  • a data structure for generating instructions for a computing device for executing a computation rule comprises for a node of a graph: a first data field for a parent node of the node in the graph, at least one second data field for a child node of the node in the graph and at least one third data field the one operation or characterizes an operand of the calculation rule.
  • the at least one third data field can define a data user, a size of at least one dimension for the calculation, an arithmetic operation, a dependency or sequence for the calculation or a value type.
  • 1 shows a device for generating instructions for a computing device
  • 6 shows a second transformation for a graph
  • 7 shows a third transformation for a graph
  • G: (V, A, s, t) denotes a directed multigraph, i.e. a graph with a large number of directed edges that can be individually identified.
  • V denotes a set of nodes, A a set of edges, s a function that assigns to each edge the node at which the edge begins and t a function that assigns each edge the node at which the edge ends.
  • a tree is a graph that defines exactly one path between two nodes.
  • a path denotes a finite sequence of edges that connect a finite set of nodes in the example that are all different from one another.
  • the instruction set architecture can be an x86 instruction set architecture, i.e. an instruction set architecture, ISA, for an x86 CPU.
  • the intermediate representation is a multigraph that represents the calculations in operators of an artificial neural network.
  • FIG. 1 a device for generating instructions for a computing device 102 for executing a computation rule is shown schematically.
  • the computing device 102 comprises a first device 104, a second device 106 and a memory 108.
  • the first device 104 comprises electrical circuits which are designed to execute specific, predetermined instructions.
  • the first device 104 is designed to have read access to the memory 108.
  • the first device 104 is designed to have write access to the memory 108.
  • the first device 104 is designed to determine the same output as a function of the same input each time a specific, predetermined instruction is executed.
  • the input is defined by values from a first memory area 110 of the memory 108.
  • the output is defined by values from a second memory area 112 of the memory 108.
  • the second memory area 112 of the memory 108 is undefined during the execution of an instruction.
  • the second memory area 112 is only used or changed after this instruction has been executed.
  • a first data line 114 can connect them.
  • the first device 104 is referred to below as a hardware accelerator.
  • the second device 106 is designed to determine instructions for the hardware accelerator as a function of a computation rule.
  • a second data line 116 can connect these.
  • the second device 106 can be designed to recognize a type of hardware accelerator.
  • the second device 106 can be designed to determine the type of hardware accelerator from a configuration entered by a user.
  • the second device 106 can be designed to inquire about the type of hardware accelerator by means of a query from the hardware accelerator and to recognize the type as a function of a response from the hardware accelerator. In this case, the hardware accelerator can be designed to send this response upon receipt of the query.
  • the hardware accelerator can also send the type without receiving a query, e.g. when switching on the hardware accelerator.
  • the second device 106 can be designed to carry out the method described below. This method can also be carried out outside the second device 106 or outside the computing device 102, a result of the method being the instructions which the second device 106 is to generate in order to control the hardware accelerator for determining the result of a calculation in accordance with the calculation rule or for determining a partial result thereof.
  • the memory 108 comprises a linear address space. Scalars or tensors can be stored in the address space.
  • a one-dimensional tensor is assigned a contiguous memory area in the address space, with individual elements of the tensor, i.e. the memory location of individual values of these elements, being addressable in a first dimension i.
  • a specified number of memory cells is defined for a value.
  • a value of an element of a tensor stored in memory 108 is stored in the memory cells which, based on a start address for the tensor in the memory area for the tensor, begin at the point in the first dimension i defined by a position of the element in the tensor.
  • the first dimension i and a second dimension j can be defined for a two-dimensional tensor.
  • the storage location of individual values is defined in each of the dimensions of the tensor as described for the one-dimensional tensor.
  • Element-wise operation e.g. addition, multiplication, division, subtraction, scalar product
  • Tensor reduction e.g. vector reduction
  • An unchangeable first value range for the first dimension i can be defined for the operations.
  • An unchangeable second range of values for the second dimension j can be defined for the operations.
  • the first range of values and / or the second range of values can be defined by the structure or the arrangement of the unchangeable electrical circuits.
  • An instruction or instructions for calculating such an operation can be represented by patterns which can be found in a structure of a graph which defines a calculation rule in which one of the operations can be used.
  • the method described below makes it possible to select a graph which makes it possible to generate the instruction or the instructions with which a result of a calculation according to the calculation rule can be calculated using the hardware accelerator.
  • the instruction or the instructions may include loading an operand, for example a vector, a tensor or a matrix, into the first memory area 110.
  • the instruction or the instructions can include reading a result or a partial result of the calculation in accordance with the arithmetic rule, for example a vector, a tensor or a matrix from the second memory area 112.
  • the instruction or instructions may include an order for writing, calculating, and / or reading.
  • the instruction or instructions may comprise an order for an arrangement of a vector, a tensor or a matrix in the memory 108.
  • an instruction can provide for a rearrangement of memory locations or their addressing in memory 108 for values that define a transpose of a vector, a tensor or a matrix in memory 108.
  • a calculation rule is represented by a graph for the intermediate representation.
  • nodes have a parent node and one or more child nodes.
  • the nodes can be one of the following types:
  • a tensor node defines the tensor dimension and an arrangement of a program loop for a repeated calculation of at least one operation over a dimension for a tensor.
  • the tensor node can, for example, define a repeated calculation in the first dimension i or the second dimension j.
  • a reduction node defines an operation for an input with multiple dimensions that leads to a reduction in the dimensions. This means that the reduction node defines a calculation whose output has fewer dimensions than its input. A specific arithmetic operation is assigned to a reduction node.
  • An example of such a calculation is a summation, for example an addition of all elements of a vector at the input by which a scalar is determined at the output.
  • a calculation node defines an element-wise function.
  • the element-wise function can provide an unchangeable sequence for its inputs.
  • the element-wise function can provide a variable sequence for its inputs. This is provided, for example, in commutative operations such as addition.
  • An input node defines an input for the calculation.
  • the input node defines a scalar, a vector, a tensor or a matrix.
  • An access node defines a memory access function with which a scalar or a dimension of a vector, a tensor or a matrix is accessed.
  • Access nodes can be connected to further access nodes. This means that more complex memory access functions can be mapped, for example an addition of two iterators or indices i + j. An addition operation can also be represented by a node of the access node type. Edges connect the nodes in the graph.
  • the first graph 200 shown by way of example in FIG. 2 is a directed graph in which the directed edges have the following meaning:
  • An edge that begins at an input node and ends at an access node defines a memory access to the dimension defined by the access node, which is required if the input defined by the input node is used for the calculation.
  • the access node defines, for example, an instruction to write the values of a tensor from this dimension into the first memory area 110 for the input.
  • An edge starting at one computation node and ending at another node defines a computation of a partial result with the operation given by the computation node, which is applied to operands defined by the other nodes.
  • Another node can be an input node, another calculation node, a reduction node or a tensor node in the example.
  • An edge starting at a reducing node and ending at another node defines a computation of a partial result with the operation given by the reducing node, which is applied to operands defined by the other nodes.
  • Another node can be an input node, a calculation node, another reduction node or a tensor node in the example. At least one of the other nodes defines a multi-dimensional input for the reduction node.
  • another node defines a scalar, which originates from a tensor, as a starting value for the calculation of an output.
  • An edge that starts at a tensor node can end at a computation node, a reduction node, or another tensor node.
  • This edge can be of a first type of edge that defines a program loop for repetitive execution of a calculation.
  • This calculation is defined, for example, by a subgraph of the graph, the root of which is the node at which the edge of the first edge type ends.
  • the edge can be of a second type of edge, which is a for the repeated calculation in the program loop defines the required partial result.
  • the subgraph includes at least one node which defines a reference to the partial result. A position of this node in a structure of the partial graph defines an order for the calculation using the partial result.
  • the reference can be represented by an additional edge of a third edge type in the graph, which connects this node directly to the same node at which the edge of the second edge type ends.
  • the program loop can be represented by an edge of a fourth edge type in the graph.
  • edges of the third edge type and the fourth edge type are assigned as a property to the node at which they begin.
  • the edges of the third type can be defined by specifying the upward movements and by specifying at least one subsequent movement along an edge of the second edge type starting from this node.
  • the edges of the fourth type can be defined by specifying the number of upward movements in the graph starting from this node. Upward movement refers to a movement from the node along an edge towards the root node of the graph.
  • the edges of the first edge type, the second edge type, the third edge type and the fourth edge type are directed edges in the example.
  • Directed edges of a fifth edge type start at a reduction node, a computation node or an input node and end at another node.
  • Edges of the first edge type and the fifth edge type are represented by arrows,
  • Edges of the second edge type are represented by dotted arrows
  • edges of the third edge type are represented by dashed arrows
  • Edges of the fourth type of edge are shown by dash-dotted arrows.
  • FIG. 2 represents a first representation of the following arithmetic rule R i; for a scalar s and matrices Q and K:
  • FIG. 3 shows a second representation of the same arithmetic rule R i; shown.
  • tensor nodes are designated with capital letters, with a dimension for an interval for a program loop for a repeated execution of a calculation at the respective tensor node being shown in square brackets [].
  • the root node of the respective graph is defined by a tensor node to which one of the dimensions of the result is assigned.
  • An input node with which one of the matrices from the calculation rule is accessed is identified with the same capital letter as the matrix is identified with.
  • each of the input nodes is assigned an access node for one dimension of the respective matrix, the respective dimension being indicated in square brackets []. Assuming that the dimension starts at zero, the size of the respective dimension can be specified as a colon followed by a number indicating the size in square brackets.
  • Compute nodes that define algebraic operations are labeled with the mathematical sign that they define.
  • a multiplication of s by the sum S is represented by a calculation node marked with *.
  • Reduction nodes are labeled with the operation that is used for the reduction. If the reduction requires an algebraic operation, this can be assigned to the reduction node as a property.
  • the reduction account is labeled S + because it is a total.
  • boundary conditions When generating instructions from the graph, an evaluation of boundary conditions can be provided. For example, the order of the calculations, which is defined by edges of the third edge type or the fourth edge type, is evaluated and adhered to by the generated instructions.
  • Boundary conditions can be defined as a property and assigned to a node. It can be provided that an algebraic operation which requires a defined arrangement of the operands in the input of the memory 108 is assigned as a property to the node to which this operation is carried out Are defined. This property is evaluated and adhered to by the generated instructions.
  • a pattern is defined that has a structure that defines a calculation rule that can be calculated particularly well by the hardware accelerator.
  • the pattern defines the instructions that fit particularly well with a specific hardware of the hardware accelerator. With the method described below, the instructions that are particularly suitable for this hardware can be generated.
  • Different hardware accelerators can comprise different hardware with electrical circuits that can calculate computation rules of a specific structure in an accelerated manner.
  • the nodes of the graph define operations or operands for executing the calculation rule.
  • the edges define a sequence of the application of operations to carry out the arithmetic rule.
  • a first structure for a graph which defines at least one operation that can be carried out by a hardware accelerator.
  • the first structure defines an arrangement of nodes and edges in the graph.
  • a calculation rule is provided.
  • the intermediate representation for the arithmetic rule is then provided in a step 202.
  • a directed first graph with nodes and edges is provided, which represents the calculation rule.
  • the first graph has the property of a tree.
  • the first graph is determined as a tree from the graph for the intermediate representation, so that there is only one path that connects each pair of nodes in the first graph.
  • parent and child nodes assigned to one another already have this property.
  • Edges that define a data dependency in the intermediate representation are assigned to the third edge type in the first graph.
  • Edges that define an iteration in the intermediate representation are assigned to the fourth edge type in the first graph.
  • the edges of the first, the second and the fifth edge type define a graph with a tree structure, in which a node that defines an iterator can be reached by a node that uses the iterator by a path that only passes through directed edges of the first, of the second and the fifth edge type is achievable.
  • the directed edge of the third type of edge or the fourth type of edge leads to the node that uses it.
  • An edge of the third edge type can be realized by a path in the tree along the first, second and fifth edge type. The path can be saved in an input node for pattern recognition.
  • An edge of the fourth edge type can be defined by specifying a path length, for example as an integer, in the node that defines the iterator. Simply by specifying this path length, the path in the tree can be covered, starting from the node that uses the iterator to the node that defines the iterator.
  • this path length replaces the specification of the node that uses the iterator.
  • the path length is stored in a leaf of the tree, ie an access node that defines the iterator.
  • the iterator corresponds to a dimension over which a tensor that is defined in a tensor node that uses this iterator is calculated.
  • the iterator corresponds, for example, to a dimension over which a reduction that is defined in a reduction node that uses this iterator is calculated.
  • a data dependency for a large number of program loops or references is stored in the respective leaves of the tree.
  • a data structure is defined with which a pattern comparison can be carried out with a large number of instructions from a set of instructions.
  • a root-to-leaf path of an instruction is defined as a character string of designations.
  • a label comprises the node type of a node in the path or an ordered list of the labels of the child nodes, which is ordered according to the direction of the directed path.
  • a finite state machine for the character string comparison.
  • the Aho-Corasick algorithm according to Alfred V. Aho and Margaret J. Corasick. 1975. Efficient String Matching: An Aid to Bibliography Search. Commun. ACM 18,6 (June 1975) 333-340. https://doi.Org/10.1145/360825.360855 can be used.
  • the first graph defines first instructions for the computing device 102 for executing the computation rule.
  • a step 206 at least a first part with a first structure is searched for in the first graph.
  • the first structure is defined in the example by a first character string. This reduces the problem of pattern matching to a problem of string matching the first string with a string representing the pattern.
  • a second part with a second structure is determined.
  • the second structure is defined in the example by a second character string.
  • the structure or pattern for replacement are defined in pairs in the example.
  • a directed acyclic, connected second graph with nodes and edges is determined as a function of the first graph. In the second graph, the first part has been replaced by the second part.
  • the second graph defines second instructions for the computing device 102 for executing the arithmetic rule.
  • a pattern is provided for at least part of a graph, the nodes and edges of which are defined by instructions that can be executed by the computing device 102. Provision can be made for instructions that can be executed by the computing device to be specified, determined or received. In this case, the pattern can be determined depending on the executable instructions.
  • the pattern is represented by at least part of a graph which, as described for the intermediate representation, is determined from the executable instructions and has a structure of a tree. The pattern is defined as a corresponding string. Pattern matching is done by comparing the first character string or the second character string with a character string that represents the pattern.
  • a step 214 depending on the pattern, either the first graph or the second graph for generating instructions for the computing device 102 is selected.
  • the first graph and the second graph are candidates which can be searched with the pattern in order to determine a suitable graph for generating the instructions for calculating the arithmetic rule.
  • a conflict is defined by the fact that two suitable instructions comprise the same node in the tree of a graph for the pattern.
  • an optimization problem can be defined as a function of a global cost function, which assigns a cost function to each instruction.
  • a solution of the Optimization problem determines which defines the pattern on which the candidates are searched.
  • An algorithm for this includes, for example, a selection function with which the pattern that represents the solution to the optimization problem is selected from all possible matching patterns.
  • the instructions that match best are selected depending on a list of conflicting instructions found during a traverse of the tree on a branch of the tree starting from a leaf.
  • the list of instructions is generated by traversing the tree once from its root.
  • the positions at which the pattern search algorithm found a pattern are added to the list.
  • the order in which the tree is traversed is: Right-to-Left pre order.
  • a branch is not pursued further, for example, if the cost function of a suitable instruction for the global node function does not bring about any improvement compared to the next possible suitable instruction.
  • a next instruction can be determined which does not overlap with the current node.
  • the next node that can be reached from the current node is determined for this purpose.
  • a function for implementing the algorithm can provide that an empty value is returned for nodes that do not represent a possible continuation.
  • the procedure is as described for the first graph.
  • a tensor node describes an independent element whose arrangement in a program flow does not affect the result.
  • the tensor node is assigned a factor that is used during code generation in order to determine suitable outer program loops and calls for the instruction for the tensor node. This means that globally well-suited parameters can be determined after the instructions have been compared.
  • the factor defines partial results that are saved and used in the following calculations. A new tensor node and a matching tensor are therefore generated for each partial result. The tensor in which the partial result is stored can be addressed and found for later use through the tensor node.
  • the instructions for the computing device 102 are either generated in a step 216 as a function of the first graph, if this in step 214 was selected, or generated depending on the second graph, if this was selected in step 214.
  • Different computing devices 102 can determine different partial results with different specialized hardware at different speeds or with different precision.
  • the pattern defines the instructions that are particularly suitable for a particular piece of hardware. In this way, the instructions that are particularly suitable for this hardware can be generated.
  • the first structure can define a first subgraph that includes a plurality of nodes and edges that define at least one operation in a first order for at least two operands.
  • the second structure defines, for example, a second subgraph that is defined by the nodes of the first subgraph.
  • the edges of the second subgraph define at least one operation in a second order for the at least two operands.
  • the at least one operation can be an element-wise arithmetic operation.
  • the first structure can be defined as shown in FIG. 5 on the left.
  • the second structure can be defined as shown in FIG. 5 on the right.
  • the first structure comprises a first node R [x: 10] at which a first edge begins.
  • the first edge ends at a second node R [y: 20]
  • a second edge begins at the second node R [y: 20] and ends at a third node +.
  • the third node + defines an operation, addition, the operands of which include a first subgraph, in the example a scalar a, and a second subgraph N (x, y) * Act (x, y).
  • the second node R [y: 20] defines a first program loop for repeated execution of the operation.
  • the first node R [x: 10] defines a second program loop for repeated execution of the first program loop.
  • the second structure comprises the first node R [x: 10], at which the first edge begins and ends at the second node R [y: 20].
  • the second edge begins at the second node R [y: 20] and ends at the third node +.
  • the operands for the operation that the third node + defines include the first subgraph a and a fourth node T (x, y).
  • the fourth node T (x, y) replaces the second subgraph N (x, y) * Act (x, y) from the first subgraph of the first structure.
  • the second structure comprises a third edge which starts at the first node R [x: 10] and ends at a fifth node T [x: 10].
  • the second structure comprises a fourth edge which begins at the fifth node T [x: 10] and ends at a sixth node T [y: 20].
  • the sixth node T [y: 20] defines a third program loop for a repeated execution of an operation of the second subgraph N (x, y) * Act (x, y).
  • the fifth node T [X: 10] defines a fourth program loop for repeated execution of the third program loop.
  • a fifth edge which begins at the fourth node T (x, y) and ends at the fifth node T [x: 10], defines an order of execution of the fourth program loop before the second program loop.
  • partial graphs are generated which define a part of the arithmetic rule with which a partial result of a part of the arithmetic rule can be completely determined.
  • the additional edge defines the sequence of execution so that data dependencies between the partial result and the use of the partial result in the calculation rule can be observed.
  • the first structure can be defined as shown in FIG. 6 on the left.
  • the second structure can be defined as shown in FIG. 6 on the right.
  • the first structure can comprise a first node R [x: 10] at which a first edge begins and ends at a second node R [y: 20].
  • a second edge begins at the second node R [y: 20] and ends at a third node T [y: 20].
  • a third edge begins at the third node T [y: 20] and ends at a fourth node T [z: 30].
  • the fourth node T [z: 30] defines a first program loop for repeated execution of a part of the arithmetic rule defined by a subgraph, the third node T [y: 20] defines a second program loop for repeated execution of the first program loop.
  • the second node R [y: 20] defines a third program loop for repeated execution of the second program loop.
  • the first node R [x: 10] defines a fourth program loop for repeated execution of the third program loop.
  • a fourth edge begins at the second node R [y: 20] and ends at a fifth node S +.
  • a fifth edge begins at the fifth node S + and ends at a sixth node T (x, y, z).
  • the sixth node T (x, y, z) defines a partial result that can be determined by calculating the part of the arithmetic rule defined by the partial graph.
  • the fifth node S + defines an operation that uses the partial result.
  • a sixth edge begins at the sixth node T (x, y, z) and ends at the third node T [y: 20].
  • the sixth edge defines an order of execution of the second program loop for determining the partial result before a first execution of the second operation in the third program loop.
  • the second structure in this case comprises the first node R [x: 10], the second node R [y: 20] and the fifth node S +.
  • the first edge begins at the first node R [x: 10] and ends at the second node R [y: 20].
  • the fourth edge begins at the second node R [y: 20] and ends at the fifth node S +.
  • the sixth node T (x, y, z) is replaced by the subgraph.
  • the first structure can define a first subgraph which comprises a plurality of nodes and edges which define a first arrangement in a memory of the computing device 102 for at least two dimensions of an operand.
  • the second structure can define a second subgraph which is defined by the nodes of the first subgraph, the edges of the second subgraph defining a second arrangement in the memory for the at least two dimensions of the operand.
  • the first arrangement can define a first tensor N for data, the second arrangement defining a second tensor N T for the data.
  • the second tensor N T is defined by the transposed first tensor N.
  • the associated input node N is shown in FIG. 7 on the left for the first tensor N and on the right for the second tensor N T.
  • the access nodes are interchanged with respect to the first arrangement.
  • the first arrangement can define a first tensor R for data, the second arrangement defining a second tensor R T for the data.
  • the second tensor R T is defined by the transposed first tensor R.
  • the first arrangement of the associated tensor nodes R [x: 10] and R [y: 20] is shown for the first tensor R on the left in FIG.
  • the second arrangement is shown on the right in FIG. 8 for the second tensor R T. In this case, the program loops are reversed.
  • the first arrangement can comprise more dimensions than the second arrangement.
  • the second arrangement is determined, for example, by linearizing a plurality of dimensions of the first arrangement.
  • the first arrangement can comprise fewer dimensions than the second arrangement.
  • the second arrangement can in this case be determined by replicating at least one dimension of a plurality of dimensions of the first arrangement or by adding a dimension filled with at least one value, in particular with at least one zero.
  • FIG. 9 shows a fusion of two outermost tensor nodes.
  • the first structure can comprise a plurality of nodes and edges which define a first arrangement in a memory of the computing device 102 for at least two dimensions x, y of an operand.
  • the first structure can be defined as shown in FIG. 9 on the left.
  • the second structure can be defined as shown in FIG. 9 on the right.
  • the first structure comprises a first node R [x: 10] at which a first edge of the first edge type begins.
  • the first edge ends at a second node R [y: 20]
  • a second edge of the first edge type begins at the second node R [y: 20] and ends at a third node +.
  • the third node + defines a first operation, in the example an addition, the operands of which are a first subgraph, in the example a scalar a, and a second subgraph that includes a fourth node T (x, y) which defines a partial result.
  • the second node R [y: 20] defines a first program loop for repeated execution of the first operation.
  • the first node R [x: 10] defines a second program loop for repeated execution of the first program loop.
  • a third edge of the second edge type begins at the first node R [x: 10] and ends at a fifth node T [x: 10].
  • a fourth edge of the first edge type begins at the fifth node T [x: 10] and ends at a sixth node T [y: 20].
  • a fifth edge of the first edge type begins at the sixth node T [y: 20] and ends at a seventh node *.
  • the seventh node * defines a second operation, in the example a multiplication for an eighth node N (x, y) and a ninth node Act (x, y).
  • the sixth node T [y: 20] defines a third program loop for repeated execution of the second operation.
  • the fifth node T [x: 10] defines a fourth program loop for repeated execution of the third program loop.
  • a sixth edge of the third edge type begins at the fourth node T (x, y) and ends at the fifth node T [x: 10]
  • the second structure in this case comprises the first node R [x: 10], the second node R [y: 20], the third node +, the first subgraph and the second subgraph as described for the first structure, with the second subgraph the fourth node T (x, y) is replaced by the sixth node T [y: 20].
  • the seventh node * the eighth node N (x, y) and the ninth node Act (x, y) are arranged as described for the first structure.
  • FIG. 10 shows the insertion of an arithmetic operation with which a partial result is determined into a partial graph which previously used this partial result.
  • the first structure can comprise a plurality of nodes and edges which define a first arrangement in a memory of the computing device 102 for at least two dimensions x, y of an operand.
  • the first structure can be defined as shown on the left in FIG.
  • the second structure can be defined as shown in FIG. 10 on the right.
  • the first structure comprises a first node R [x: 10] at which a first edge of the first edge type begins.
  • the first edge ends at a second node R [y: 20]
  • a second edge of the first edge type begins at the second node R [y: 20] and ends at a third node +.
  • the third node + defines a first operation, in the example an addition, the operands of which include a first subgraph, in the example a scalar a, and a second subgraph that includes a fourth node T (x, y) that defines a partial result.
  • the second node R [y: 20] defines a first program loop for repeated execution of the first operation.
  • the first node R [x: 10] defines a second program loop for repeated execution of the first program loop.
  • a third edge of the second edge type begins at the second node R [y: 20] and ends at a fifth node T [y: 20].
  • a fourth edge of the first edge type begins at the fifth node T [y: 20] and ends at a sixth node *.
  • the sixth node * defines a second operation, in the example a multiplication for a seventh node N (x, y) and an eighth node Act (x, y).
  • the fifth node T [y: 20] defines a third program loop for repeated execution of the second operation.
  • a sixth edge of the third edge type begins at the fourth node T (x, y) and ends at the fourth node T [y: 20]
  • the second structure in this case comprises the first node R [x: 10], the second node R [y: 20], the third node +, the first subgraph and the second subgraph as described for the first structure, with the second Subgraph the fourth node T (x, y) is replaced by the fifth node T [y: 20].
  • the sixth node *, the seventh node N (x, y) and the eighth node Act (x, y) are arranged as described for the first structure.
  • FIG. 11 shows a separation of a reduction from one subgraph into another subgraph. This creates a new intermediate result that is first determined and then included in the reduction.
  • the first structure can be defined as shown in FIG. 11 on the left.
  • the second structure can be defined as shown in FIG. 11 on the right.
  • the first structure can comprise a first node R [x: 10] at which a first edge begins and ends at a second node R [y: 20].
  • a second edge begins at the second node R [y: 20] and ends at a third node S +.
  • a third edge begins at the third node S + and ends at a fourth node *.
  • the fourth node * defines a first operation, in the example a multiplication for a fifth node N (x, z) and a sixth node Act (z, y) depending on at least three dimensions.
  • a first dimension x and a second dimension y are defined for the fifth node N (x, z) and the second dimension and a third dimension y are defined for the sixth node Act (z, y).
  • the third node S + defines a second operation and a first program loop for repeated execution of the first operation.
  • a fourth edge begins at the third node S + and ends at a seventh node 0, which defines a starting value for the reduction.
  • the first node defines a second program loop for a repeated execution of the second operation for the first dimension x. A repeated execution over the third dimension y is therefore not necessary.
  • the second structure defines the first node R [x: 10] at which the first edge begins and ends at the second node R [y: 20].
  • the second edge begins at the second node R [y: 20] and ends at the third node S +.
  • the fourth node * is replaced in the second structure by an eighth node T (x, y, z), which defines a partial result.
  • the third node S + defines the first program loop and the second operation for the eighth node T (x, y, z), ie the partial result, and the seventh node, ie the start value for the reduction.
  • the second structure comprises a fifth edge which starts at the first node R [x: 10] and ends at a ninth node T [y: 20].
  • a sixth edge begins at the ninth node T [y: 20] and ends at a tenth node T [y: 20].
  • a seventh edge begins at the tenth node T [y: 20] and ends at an eleventh node T [z: 30].
  • An eighth edge begins at the eleventh node T [z: 30] and ends at the fourth node *.
  • the fourth node * defines the first operation, in the example the multiplication for the fifth node N (x, y, z) and the sixth node Act (z, y) depending on at least three dimensions.
  • the first dimension x, the second dimension z and the third dimension y are defined for the fifth node N (x, y, z).
  • the ninth node T [y: 20], the tenth node T [y: 20] and the eleventh node T [z: 30] define a third program loop for the repeated execution of the first operation. This determines the same partial result.
  • a ninth edge of the third edge type begins at the eighth node T (x, y, z) and ends at the ninth node T [y: 20]. This represents the new data dependency in the second structure.
  • a tenth edge of the fourth edge type begins at the eighth node T (x, y, z) and ends at the third node S +. This shows the new program loop in the second structure.
  • the data for the operands and operations are defined by an input for the arithmetic rule or by a partial result of the arithmetic rule.
  • the first structure can define a first subgraph comprising a first node N at which no edge begins.
  • the first node can define a first memory area for the computing device 102 in at least two dimensions [i], [j].
  • This first structure comprises a second node which defines an operation for values in the first memory area.
  • the method can provide that a second memory area is defined for the computing device 102 in at least one of the dimensions [j] of the first memory area.
  • the second structure defines a second subgraph in which the first node of the first subgraph is replaced by a third node N which defines the second memory area.
  • the second structure defines a program loop for at least one dimension of the first memory area that is missing in the second memory area, which defines a repeated execution of the operation on the second operand over this dimension.
  • the first graph and the resulting plurality of second graphs define candidates which can be searched using the pattern in order to determine a suitable graph for generating the instructions for calculating the arithmetic rule. This can take place when connecting a hardware accelerator or when entering a previously unknown arithmetic rule before it is calculated with the arithmetic unit 102. As a result, the correct instructions for any hardware accelerator and any computing rules can be generated when the computing device 102 is in operation.
  • This computing device 102 can be operated with any hardware accelerators that can be produced independently of the computing device itself.
  • the computation rule can define or comprise a kernel which defines the artificial neural network.
  • the node type is one from the group of tensor nodes, reduction nodes, calculation nodes, input nodes, access nodes.
  • Exemplary data structures are shown in FIG.
  • parent node denotes a node at which an edge begins, which ends at the node whose data structure includes a data field which defines the parent node.
  • child node denotes a node, an which is started by an edge whose data structure includes a data field that defines the child node. If there is no parent node or no child node, this is defined in the example by an empty entry in the corresponding data field.
  • the node type tensor node is defined by a data structure 900 that includes a data field 902 for a parent node, a data field 904 for a child node that can be reached with an edge of the first edge type, a data field 906 for a child node that can be reached with an edge of the second edge type comprises a data field 908 for a data user and a data field 910 for a size of at least one dimension of the tensor.
  • the data field 902 for the parent node can define a different tensor node or contain an empty entry.
  • the data field 904 for the child node that can be reached with an edge of the first edge type can define a node from the group of tensor nodes, reduction nodes, calculation nodes, input nodes.
  • the data field 906 for the child node that can be reached with an edge of the second edge type can define another tensor node.
  • the data field 908 for the data user can define an entry or contain an empty entry.
  • the size data field 910 can define an interval.
  • interval includes an entry for an upper limit of the dimension, a lower limit of the dimension and a step size for the repeated execution of the program loop.
  • the upper limit, the lower limit and the step size can be integer values.
  • the node type reduction node is defined by a data structure 912 that contains a data field 902 for a parent node, a data field 904 for a child node that can be reached with an edge of the first edge type, and a data field 906 for a child node that can be reached with an edge of the second edge type and a data field 914 for a size of at least one dimension for the reduction.
  • the data field 902 for the parent node can define a node from the group of tensor nodes, reduction nodes, and calculation nodes.
  • the data field 904 for the child node that can be reached with an edge of the first edge type can define an input node.
  • the data field 906 for the child node that can be reached with an edge of the second edge type can define a node from the group of reduction nodes, calculation nodes, input nodes.
  • the size data field 914 may define an interval.
  • interval includes an entry for an upper limit of the dimension, a lower limit of the dimension and a step size for the repeated execution of the calculation for the reduction.
  • the upper limit, the lower limit and the step size can be integer values.
  • the node type calculation node is defined by a data structure 916 that contains a data field 902 for a parent node, a data field 904 for a child node that can be reached with an edge of the first edge type, and a data field 906 for a child node that can be reached with an edge of the second edge type and a data field 918 for an operation.
  • the data field 902 for the parent node can define a node from the group of tensor nodes, reduction nodes, and calculation nodes.
  • the data field 904 for the child node that can be reached with an edge of the first edge type can define a node from the group of reduction nodes, calculation nodes, input nodes.
  • the data field 906 for the child node that can be reached with an edge of the second edge type can define a node from the group of reduction nodes, calculation nodes, input nodes.
  • the data field 918 for the operation can define an arithmetic operation, e.g. addition +, subtraction, multiplication *, division: or other unary and binary operations, e.g. sine, cosine, tangent, maximum (max), minimum (min), exponential function, or Bitshift.
  • the node type input node is defined by a data structure 920 which comprises a data field 902 for a parent node, a data field 922 for a dependency or sequence based on an edge of the third edge type and a data field 924 for one or more child nodes.
  • the data field 902 for the parent node can define a node from the group of tensor nodes, reduction nodes, and calculation nodes.
  • the data field 922 for a dependency due to an edge of the third edge type can define a tensor node to which the edge leads or contain an empty entry.
  • the data field 924 for the one or more child nodes may include a list of one or more access nodes.
  • the node type access node is defined by a data structure 926 which comprises a data field 902 for a parent node, a data field 928 for a value type and a data field 924 for one or more child nodes.
  • the data field 902 for the parent node can define a node from the group of input nodes or access nodes.
  • the data field 928 for the value type can define a type for the data that the access node references from the memory.
  • the type can be iterator, operation, or scalar constant.
  • the data field 924 for the child node may comprise a list of one or more access nodes or an empty entry.
  • the access nodes can define one of the dimensions of a vector, tensor, or matrix in memory 108. There is access to multiple dimensions can be defined by a chain of access nodes, a first access node defining a first dimension and a last access node in the chain defining a highest dimension. An access node for the first dimension is defined as a child node in an input node. The access node for the first dimension defines an access node for the second dimension as a child node. This continues until an access node defines the last access node for the highest dimension. The last access node defines the empty entry for the child node.
  • the instructions for the pattern search can be found in Alfred V. Aho and
  • the pattern recognition can be done by one of Christoph M. Hoffmann and Michael J. O’Donnell. 1982. Pattern Matching in Trees. J. ACM 29, 1 (Jan 1982), 68-95. https://doi.Org/10.1145/322290.322295 described search process.

Abstract

Computerimplementiertes Verfahren und Vorrichtung zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift, wobei ein erster Graph mit Knoten und Kanten bereitgestellt wird (204), der erste Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei im ersten Graph wenigstens ein erster Teil mit einer ersten Struktur gesucht wird (206), wobei abhängig vom wenigstens einen ersten Teil ein zweiter Teil mit einer zweiten Struktur bestimmt wird (208), wobei abhängig vom ersten Graph ein gerichteter azyklischer zusammenhängender zweiter Graph mit Knoten und Kanten bestimmt wird (210), wobei im zweiten Graph der erste Teil durch den zweiten Teil ersetzt ist, wobei der zweite Graph zweite Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei ein Muster für wenigstens einen Teil eines Graphs bereitgestellt wird (212), dessen Knoten und Kanten durch Instruktionen definiert ist, die von der Recheneinrichtung ausführbar sind, wobei die Instruktionen für die Recheneinrichtung entweder abhängig vom ersten Graph oder abhängig vom zweiten Graph erzeugt werden (216), und wobei abhängig vom Muster der erste Graph oder der zweite Graph zum Erzeugen von Instruktionen für die Recheneinrichtung ausgewählt wird (214).

Description

Beschreibung
Titel
Vorrichtung und Verfahren zum Erzeugen von Instruktionen für eine
Recheneinrichtung zur Ausführung einer Rechenvorschrift
Stand der Technik
Die Erfindung geht aus von einer Vorrichtung und einem Verfahren zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift.
Tianqi Chen, Thierry Moreau, Ziheng Jiang, Haichen Shen, Eddie Q. Yan,
Leyuan Wang, Yuwei Hu, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy. 2018. TVM: End-to-End Optimization Stack for Deep Learning. CoRR abs/1802.04799 (2018). arXiv: 1802.04799 http://arxiv.org/abs/1802.04799 offenbart ein als TVM bezeichnetes Werkzeug zur Auswahl von Instruktionen für elektronische Schaltkreise, die für spezielle mathematische Berechnungen hergestellt sind. Diese werden als Accelerator oder Hardwarebeschleuniger bezeichnet und beispielsweise für Berechnungen in künstlichen neuronalen Netzwerken eingesetzt.
M. Sotoudeh, A. Venkat, M. Anderson, E. Georganas, A. Heinecke, J. Knigh, ISA Mapper: A Compute and Hardware Agnostic Deep LearningCompiler, https://dl.acm.org/doi/10.1145/3310273.3321559 offenbart eine Möglichkeit, bei der Erzeugung von Instruktionen mit Schleifennestern umzugehen.
Es ist wünschenswert, ein effizientes Vorgehen zur Erzeugung von Instruktionen für beliebige derartige Hardwarebeschleuniger und beliebige Rechenvorschriften bereitzustellen.
Offenbarung der Erfindung Dies wird durch den Gegenstand der unabhängigen Ansprüche erreicht.
Ein computerimplementiertes Verfahren zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift sieht vor, dass ein gerichteter erster Graph mit Knoten und Kanten bereitgestellt wird, der erste Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei im ersten Graph wenigstens ein erster Teil mit einer ersten Struktur gesucht wird, wobei abhängig vom wenigstens einen ersten Teil ein zweiter Teil mit einer zweiten Struktur bestimmt wird, wobei abhängig vom ersten Graph ein gerichteter zweiter Graph mit Knoten und Kanten bestimmt wird, wobei im zweiten Graph der erste Teil durch den zweiten Teil ersetzt ist, wobei der zweite Graph zweite Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei ein Muster für wenigstens einen Teil eines Graphs bereitgestellt wird, dessen Knoten und Kanten durch Instruktionen definiert ist, die von der Recheneinrichtung ausführbar sind, wobei die Instruktionen für die Recheneinrichtung entweder abhängig vom ersten Graph oder abhängig vom zweiten Graph erzeugt werden, und wobei abhängig vom Muster der erste Graph oder der zweite Graph zum Erzeugen von Instruktionen für die Recheneinrichtung ausgewählt wird. Der erste Graph kann ein gerichteter azyklischer zusammenhängender Graph sein. Im ersten Graph werden Teilgraphen gefunden, die einem Suchmuster entsprechen. Für diese Teilgraphen werden neue Teilgraphen erzeugt, die Instruktionen definieren, mit denen dasselbe Teilergebnis vollständig bestimmbar ist. Mit den neuen Teilgraphen wird ein zweiter Graph erzeugt. Unterschiedliche Recheneinrichtungen können verschiedene Teilergebnisse mit verschiedener spezialisierter Hardware unterschiedlich schnell oder präzise bestimmen. Für eine bestimmte Hardware wird einer der Graphen ausgewählt, mit dem die Instruktionen erzeugt werden. Das Muster definiert die Instruktionen, die besonders gut zur bestimmten Hardware passen. Dadurch können die für diese Hardware besonders gut geeigneten Instruktionen erzeugt werden. Durch die gerichteten Kanten sind Datenabhängigkeiten darstellbar, die bei der Auswahl des Graphen berücksichtigt werden. Die Knoten können Operationen oder Operanden zur Ausführung der Rechenvorschrift definieren, wobei die Kanten eine Reihenfolge der Anwendung von Operationen zur Ausführung der Rechenvorschrift definieren.
Es kann vorgesehen sein, dass abhängig von der Rechenvorschrift, ein Graph bereitgestellt wird, der einen Knoten umfasst, der einen Iterator für eine Operation zur Ausführung der Rechenvorschrift definiert, wobei ein Länge eines Pfads im Graph zwischen einem Knoten, der den Iterator verwendet und dem Knoten, der den Iterator definiert, bestimmt wird, wobei im Knoten, der den Iterator verwendet ein Verweis auf den Knoten, der den Iterator definiert, durch eine Angabe ersetzt wird, die die Länge des Pfads umfasst, und wobei der gerichtete erste Graph abhängig von dem Knoten, der die Länge des Pfads umfasst, bestimmt wird. Dadurch ist statt eines Verweises auf einen Knoten, der im Graph eine Programmschleife oder für eine Reduktion von Dimensionen definiert, die Länge des Pfads definiert. Der Knoten, der den Iterator verwendet, ist ausgehend vom Knoten der den Iterator definiert, im ersten Graph dadurch erreichbar, dass solange zu einem Kindknoten sein Elternknoten bestimmt wird, bis die Länge des Pfads erreicht ist.
Die erste Struktur kann einen ersten Teilgraph definieren, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Operanden wenigstens eine Operation in einer ersten Reihenfolge definieren, wobei die zweite Struktur einen zweiten Teilgraph definiert, der durch die Knoten des ersten Teilgraphs definiert ist, wobei die Kanten des zweiten Teilgraphs für die wenigstens zwei Operanden Owenigstens eine Operation in einer zweiten Reihenfolge definieren, wobei die wenigstens eine Operation eine elementweise Operation definiert.
Die erste Struktur kann durch eine erste Zeichenfolge definiert sein, die einen Pfad im ersten Graph definiert, wobei die zweite Struktur durch eine zweite Zeichenfolge definiert ist, die einen Pfad im zweiten Graph definiert. Dadurch können Musterabgleiche durch Zeichenfolgenvergleiche erfolgen.
Die erste Zeichenfolge und/oder die zweite Zeichenfolge kann eine geordnete Liste von Bezeichnungen für Knoten im Pfad umfassen, die den Pfad definiert. Dadurch sind Pfade im Zeichenfolgenvergleich besonders gut auffindbar. Die erste Struktur kann einen ersten Teilgraphen definieren, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Dimensionen eines Operanden eine erste Anordnung in einem Speicher der Recheneinrichtung definieren, wobei die zweite Struktur einen zweiten Teilgraphen definiert, der durch die Knoten des ersten Teilgraphs definiert ist, wobei die Kanten des zweiten Teilgraphs für die wenigstens zwei Dimensionen des Operanden eine zweite Anordnung im Speicher definieren.
Die erste Anordnung kann einen ersten Tensor für Daten definieren, wobei die zweite Anordnung einen zweiten Tensor für die Daten definiert, wobei der zweite Tensor durch den transponierten ersten Tensor definiert ist.
Die erste Anordnung kann gegenüber der zweiten Anordnung mehr Dimensionen umfassen, wobei die zweite Anordnung durch Linearisieren einer Vielzahl von Dimensionen der ersten Anordnung bestimmt wird.
Die erste Anordnung kann gegenüber der zweiten Anordnung weniger Dimensionen umfassen, wobei die zweite Anordnung durch Replizieren wenigstens einer Dimension einer Vielzahl von Dimensionen der ersten Anordnung oder durch Hinzufügen einer mit wenigstens einem Wert, insbesondere mit wenigstens einer Null, aufgefüllten Dimension bestimmt wird.
Die Daten können durch einen Eingang für die Rechenvorschrift oder durch ein Teilergebnis der Rechenvorschrift definiert sein.
Die erste Struktur kann einen ersten Teilgraph definieren, der einen ersten Knoten umfasst, an dem keine Kante beginnt, wobei der erste Knoten einen ersten Speicherbereich für die Recheneinrichtung in wenigstens zwei Dimensionen definiert, wobei die erste Struktur einen zweiten Knoten umfasst, der eine Operation für Werte im ersten Speicherbereich definiert, wobei ein zweiter Speicherbereich für die Recheneinrichtung in wenigstens einer der Dimensionen des ersten Speicherbereichs definiert wird, wobei die zweite Struktur einen zweiten Teilgraph definiert, in dem der erste Knoten des ersten Teilgraphs durch einen dritten Knoten ersetzt ist, der den zweiten Speicherbereich definiert, wobei die zweite Struktur für wenigstens eine Dimension des ersten Speicherbereichs, die im zweiten Speicherbereich fehlt, eine Programmschleife definiert, die eine wiederholte Ausführung der Operation mit dem zweiten Operanden über dieser Dimension definiert.
Es kann vorgesehen sein, dass eine Vielzahl erster Strukturen bereitgestellt wird, wobei für erste Strukturen, die im ersten Graph gefunden werden, eine Vielzahl zweiter Graphen bestimmt wird, wobei in der Vielzahl zweiter Graphen nach der Vielzahl erster Strukturen gesucht wird. Die Suche wird iterativ wiederholt, bis kein weiterer Teilgraph mehr gefunden wird, der dem Suchmuster entspricht.
Von der Recheneinrichtung können ausführbare Instruktionen vorgegeben, bestimmt oder empfangen werden, wobei das Muster abhängig von den ausführbaren Instruktionen bestimmt wird.
Aus einer Vielzahl Datenstrukturen für Knoten des ersten Graphs wird vorzugsweise eine Datenstruktur für einen Knoten des ersten Graphs bestimmt, die ein Datenfeld umfasst, das eine Operation definiert, die auf andere Knoten anzuwenden ist, wobei eine Datenstruktur für einen Knoten des zweiten Graphs mit derselben Datenstruktur bestimmt wird, wobei ein Datenfeld, das einen Knoten definiert, auf den die Operation anzuwenden ist, durch ein Datenfeld ersetzt wird, in dem ein anderer Knoten definiert ist, auf den die Operation anzuwenden ist, wobei der andere Knoten entweder in einem anderen Datenfeld der Datenstruktur für den Knoten definiert ist, oder wobei der andere Knoten in einem Datenfeld einer Datenstruktur eines weiteren Knotens definiert ist, auf den ein Datenfeld aus der Datenstruktur des Knotens des ersten Graphs verweist. Dadurch wird eine Reihenfolge der Instruktionen für eine Berechnung vertauscht.
Aus einer Vielzahl Datenstrukturen für Knoten des ersten Graphs wird vorzugsweise eine Datenstruktur für einen Knoten des ersten Graphs bestimmt, die ein Datenfeld umfasst, das eine Liste mit anderen Knoten definiert, wobei eine Datenstruktur für einen Knoten des zweiten Graphs mit derselben Datenstruktur bestimmt wird, wobei das Datenfeld, das die Liste definiert, durch ein Datenfeld ersetzt wird, in dem ein erster Eintrag aus der Liste mit einem zweiten Eintrag aus der Liste vertauscht ist. Dadurch wird an einem Eingangsknoten statt auf einen Vektor, einen Tensor oder eine Matrix auf deren Transponierte zugegriffen. Vorzugsweise wird wenigstens ein Knoten bestimmt, der eine Programmschleife zur Bestimmung eines Ergebnis definiert, wobei dem Knoten ein Parameter zugeordnet wird, der eine Speicherkachel im Speicher charakterisiert, wobei abhängig vom Parameter eine erste Programmschleife und eine zweite Programmschleife bestimmt werden, wobei die erste Programmschleife wenigstens eine Instruktion zur Bestimmung des Ergebnis und eine Instruktion für einen Aufruf der zweiten Programmschleife umfasst, mit der ein Teilergebnis dafür bestimmbar ist. Dies ermöglicht ein Segmentieren der Programmschleifen, falls die Instruktionen kleiner als die Dimensionen der Rechenvorschrift sind.
Eine Vorrichtung zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift ist ausgebildet, das Verfahren auszuführen.
Eine Datenstruktur zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift umfasst für einen Knoten eines Graphs: ein erstes Datenfeld für einen Elternknoten des Knotens im Graph, wenigstens ein zweites Datenfeld für einen Kindknoten des Knotens im Graph und wenigstens ein drittes Datenfeld das eine Operation oder einen Operanden der Rechenvorschrift charakterisiert.
Das wenigstens eine dritte Datenfeld kann einen Datennutzer, eine Größe wenigstens einer Dimension für die Berechnung, eine arithmetische Operation, eine Abhängigkeit oder Reihenfolge für die Berechnung oder einen Wertetyp definieren.
Weitere vorteilhafte Ausführungsformen ergeben sich aus der folgenden Beschreibung und der Zeichnung. In der Zeichnung zeigt:
Fig. 1 eine Vorrichtung zum Erzeugen von Instruktionen für eine Recheneinrichtung,
Fig. 2 einen ersten Graphen,
Fig. 3 einen zweiten Graphen,
Fig. 4 Schritte in einem Verfahren zum Erzeugen von Instruktionen für eine Recheneinrichtung,
Fig. 5 eine erste Transformation für einen Graphen,
Fig. 6 eine zweite Transformation für einen Graphen, Fig. 7 eine dritte Transformation für einen Graphen,
Fig. 8 eine vierte Transformation für einen Graphen,
Fig. 9 eine fünfte Transformation für einen Graphen,
Fig. 10 eine sechste Transformation für einen Graphen,
Fig. 11 eine siebte Transformation für einen Graphen,
Fig. 12 Datenstrukturen.
Im folgenden bezeichnet G := (V, A, s, t) einen gerichteten Multigraphen, d.h. einen Graphen mit einer Vielzahl gerichteter Kanten, die einzeln identifizierbar sind.
V bezeichnet eine Menge Knoten, A eine Menge Kanten, s eine Funktion, die jeder Kante den Knoten zuordnet, an dem die Kante beginnt und t eine Funktion, die jeder Kante den Knoten zuordnet an dem die Kante endet.
Mit Baum wird ein Graph bezeichnet, der genau einen Pfad zwischen zwei Knoten definiert. Ein Pfad bezeichnet im Beispiel eine endliche Sequenz von Kanten, die eine im Beispiel endliche Menge von Knoten verbindet, die alle voneinander verschieden sind.
Eine auf einem Graph basierende Repräsentation, die eine Berechnungssequenz und -hierarchie sowie dafür erforderliche Speicherzugriffsmuster für sowohl einen Kernel als auch für eine Befehlssatzarchitektur erfasst, wird im Folgenden als Zwischenrepräsentation bezeichnet. Die Befehlssatzarchitektur kann eine x86-Befehlssatzarchitektur, d.h. eine Instruction Set Architecture, ISA, für eine x86-CPU sein.
Die Zwischenrepräsentation ist im Beispiel ein Multigraph, der die Berechnungen in Operatoren eines künstlichen neuronalen Netzwerks repräsentiert.
In Figur 1 ist eine Vorrichtung zum Erzeugen von Instruktionen für eine Recheneinrichtung 102 zur Ausführung einer Rechenvorschrift schematisch dargestellt.
Die Recheneinrichtung 102 umfasst eine erste Einrichtung 104, eine zweite Einrichtung 106 und einen Speicher 108. Die erste Einrichtung 104 umfasst im Beispiel elektrische Schaltkreise, die zur Ausführung bestimmter, vorgegebener Instruktionen ausgebildet ist. Die erste Einrichtung 104 ist ausgebildet, auf den Speicher 108 lesend zuzugreifen. Die erste Einrichtung 104 ist ausgebildet, auf den Speicher 108 schreibend zuzugreifen. Die erste Einrichtung 104 ist ausgebildet, bei jeder Ausführung einer bestimmten, vorgegebenen Instruktion abhängig von demselben Eingang denselben Ausgang zu bestimmen. Der Eingang ist im Beispiel durch Werte aus einem ersten Speicherbereich 110 des Speichers 108 definiert. Der Ausgang ist im Beispiel durch Werte aus einem zweiten Speicherbereich 112 des Speichers 108 definiert. Im Beispiel ist der zweite Speicherbereich 112 des Speichers 108 während der Ausführung einer Instruktion Undefiniert. Im Beispiel wird der zweite Speicherbereich 112 erst nach der Ausführung dieser Instruktion verwendet oder verändert. Eine erste Datenleitung 114 kann diese verbinden.
Die erste Einrichtung 104 wird im Folgenden als Hardwarebeschleuniger bezeichnet.
Die zweite Einrichtung 106 ist ausgebildet, abhängig von einer Rechenvorschrift Instruktionen für den Hardwarebeschleuniger zu bestimmen. Eine zweite Datenleitung 116 kann diese verbinden Die zweite Einrichtung 106 kann ausgebildet sein, einen Typ des Hardwarebeschleunigers zu erkennen. Die zweite Einrichtung 106 kann ausgebildet sein, den Typ des Hardwarebeschleunigers aus einer von einem Benutzer eingegebenen Konfiguration zu bestimmen. Die zweite Einrichtung 106 kann ausgebildet sein, den Typ des Hardwarebeschleunigers durch eine Abfrage vom Hardwarebeschleuniger zu erfragen und den Typ abhängig von einer Antwort des Hardwarebeschleunigers zu erkennen. Der Hardwarebeschleuniger kann in diesem Fall ausgebildet sein, diese Antwort bei Erhalt der Abfrage zu senden.
Der Hardwarebeschleuniger kann den Typ auch ohne Erhalt einer Abfrage z.B. beim Einschalten des Hardwarebeschleunigers senden.
Die zweite Einrichtung 106 kann ausgebildet sein, das im Folgenden beschriebene Verfahren auszuführen. Dieses Verfahren kann auch außerhalb der zweiten Einrichtung 106 oder außerhalb der Recheneinrichtung 102 ausgeführt werden, wobei ein Ergebnis des Verfahrens die Instruktionen definiert, die die zweite Einrichtung 106 erzeugen soll, um den Hardwarebeschleuniger zur Bestimmung des Ergebnisses einer Berechnung gemäß der Rechenvorschrift oder zur Bestimmung eines Teilergebnisses daraus anzusteuern.
Der Speicher 108 umfasst im Beispiel einen linearen Adressraum. Im Adressraum können Skalare oder Tensoren gespeichert werden. Einem eindimensionalen Tensor wird im Beispiel im Adressraum ein zusammenhängender Speicherbereich zugewiesen, wobei einzelne Elemente des Tensors, d.h. der Speicherort einzelner Werte dieser Elemente, in einer ersten Dimension i adressierbar sind. Im Beispiel ist für einen Wert eine vorgegebene Anzahl Speicherzellen definiert. Im Beispiel ist ein Wert eines Elements eines im Speicher 108 gespeicherten Tensors in den Speicherzellen gespeichert, die ausgehend von einer Startadresse für den Tensor im Speicherbereich für den Tensor bei der durch eine Position des Elements im Tensor definierten Stelle in der ersten Dimension i beginnen.
Für einen zweidimensionalen Tensor können die erste Dimension i und eine zweite Dimension j definiert sein. Der Speicherort einzelner Werte ist im Beispiel in jeder der Dimensionen des Tensors wie für den eindimensionalen Tensor beschrieben definiert.
Es kann vorgesehen sein, dass der Hardwarebeschleuniger unveränderliche elektrische Schaltkreise zur Berechnung einer der Operationen aus der folgenden nicht abschließenden Liste von für ein- und/oder mehrdimensionale Tensoren aufweist:
Elementweise Operation, z.B. Addition, Multiplikation, Division, Subtraktion, Skalarprodukt,
Tensorreduktion, z.B. Vektorreduktion
Für die Operationen kann ein unveränderlicher erster Wertebereich für die erste Dimension i definiert sein. Für die Operationen kann ein unveränderlicher zweiter Wertebereich für die zweite Dimension j definiert sein. Der erste Wertebereich und/oder der zweite Wertebereich können durch den Aufbau oder die Anordnung der unveränderlichen elektrischen Schaltkreise definiert sein. Eine Instruktion oder Instruktionen zur Berechnung einer derartigen Operation können durch Muster repräsentiert werden, die in einer Struktur eines Graphs auffindbar sind, der eine Rechenvorschrift definiert, in der eine der Operationen verwendet werden kann.
Das im Folgenden beschriebene Verfahren ermöglicht es, einen Graphen auszuwählen, der es ermöglicht, die Instruktion oder die Instruktionen zu erzeugen, mit denen ein Ergebnis einer Berechnung gemäß der Rechenvorschrift unter Verwendung des Hardwarebeschleunigers berechenbar ist. Die Instruktion oder die Instruktionen können ein Laden eines Operanden, beispielsweise eines Vektors, eines Tensors oder einer Matrix in den ersten Speicherbereich 110 umfassen. Die Instruktion oder die Instruktionen können ein Lesen eines Ergebnisses oder eines Teilergebnisses der Berechnung gemäß der Rechenvorschrift, beispielsweise eines Vektors, eines Tensors oder einer Matrix aus dem zweiten Speicherbereich 112 umfassen. Die Instruktion oder die Instruktionen können eine Reihenfolge für das Schreiben, das Berechnen und/oder das Lesen umfassen. Die Instruktion oder die Instruktionen können eine Reihenfolge für eine Anordnung eines Vektors, eines Tensors oder einer Matrix im Speicher 108 umfassen. Beispielsweise kann eine Instruktion eine Umsortierung von Speicherstellen oder von deren Adressierung im Speicher 108 für Werte vorsehen, die eine Transponierte eines Vektors, eines Tensors oder einer Matrix im Speicher 108 definiert.
Im Beispiel wird eine Rechenvorschrift durch einen Graphen für die Zwischenrepräsentation repräsentiert. In der Zwischenrepräsentation weisen Knoten ein Elternknoten und ein oder mehrere Kinderknoten auf. Die Knoten können einen der folgenden Typen aufweisen:
Tensorknoten:
Ein Tensorknoten definiert die Tensordimension und eine Anordnung einer Programmschleife für eine wiederholte Berechnung wenigstens einer Operation über eine Dimension für einen Tensor. Der Tensorknoten kann beispielsweise eine wiederholte Berechnung in der ersten Dimension i oder der zweiten Dimension j definieren. Reduktionsknoten:
Ein Reduktionsknoten definiert für einen Eingang mit mehreren Dimensionen eine Operation, die zu einer Reduktion der Dimensionen führt. Das bedeutet, der Reduktionsknoten definiert eine Berechnung, deren Ausgang weniger Dimensionen hat, als deren Eingang. Einem Reduktionsknoten ist eine bestimmte arithmetische Operation zugewiesen.
Ein Beispiel für eine derartige Berechnung ist eine Summenbildung, beispielsweise eine Addition aller Elemente eines Vektors am Eingang durch die ein Skalar am Ausgang bestimmt wird.
Berechnungsknoten:
Ein Berechnungsknoten definiert eine elementweise Funktion. Die elementweise Funktion kann für ihre Eingänge eine unveränderliche Reihenfolge vorsehen.
Dies ist beispielsweise für eine Subtraktion vorgesehen. Die elementweise Funktion kann für ihre Eingänge eine veränderliche Reihenfolge vorsehen. Dies ist beispielsweise bei kommutativen Operationen wie der Addition vorgesehen.
Eingangsknoten:
Ein Eingangsknoten definiert einen Eingang für die Berechnung. Beispielsweise definiert der Eingangsknoten einen Skalar, einen Vektor, einen Tensor oder eine Matrix.
Zugriffsknoten:
Ein Zugriffsknoten definiert eine Speicherzugriffsfunktion mit der auf einen Skalar oder auf eine Dimension eines Vektors, eines Tensors oder einer Matrix zugegriffen wird.
Vom Zugriffsknoten müssen keine Kanten des Graphen ausgehen.
Zugriffknoten können mit weiteren Zugriffknoten verbunden sein. Damit können komplexere Speicherzugriffsfunktionen abgebildet werden, zum Beispiel eine Addition von zwei Iteratoren oder Indizes i+j. Eine Additionsoperation kann ebenfalls durch einen Knoten des Typs Zugriffsknoten abgebildet sein. Kanten verbinden die Knoten im Graph. Der beispielhaft in Figur 2 dargestellte erste Graph 200 ist ein gerichteter Graph in dem die gerichteten Kanten folgende Bedeutung haben:
Eine Kante, die an einem Eingangsknoten beginnt und an einem Zugriffsknoten endet definiert einen Speicherzugriff auf die vom Zugriffsknoten definierte Dimension, der erforderlich ist, wenn der durch den Eingangsknoten definierte Eingang für die Berechnung verwendet wird. Der Zugriffsknoten definiert beispielsweise eine Instruktion, die Werte eines Tensors aus dieser Dimension in den ersten Speicherbereich 110 für den Eingang zu schreiben.
Eine Kante, die an einem Berechnungsknoten beginnt und an einem anderen Knoten endet, definiert eine Berechnung eines Teilergebnisses mit der vom Berechnungsknoten vorgegebenen Operation, die auf Operanden angewendet wird, die durch die anderen Knoten definiert sind. Ein anderer Knoten kann im Beispiel ein Eingangsknoten, ein anderer Berechnungsknoten, ein Reduktionsknoten oder ein Tensorknoten sein.
Eine Kante, die an einem Reduktionsknoten beginnt, und ein einem anderen Knoten endet, definiert eine Berechnung eines Teilergebnisses mit der vom Reduktionsknoten vorgegebenen Operation, die auf Operanden angewendet wird, die durch die anderen Knoten definiert sind. Ein anderer Knoten kann im Beispiel ein Eingangsknoten, ein Berechnungsknoten, ein anderer Reduktionsknoten oder ein Tensorknoten sein. Wenigstens einer der anderen Knoten definiert einen mehrdimensionalen Eingang für den Reduktionsknoten.
Es kann vorgesehen sein, dass ein anderer Knoten einen Skalar definiert, der aus einem Tensor stammt, als Startwert für die Berechnung eines Ausgangs definiert.
Eine Kante, die an einem Tensorknoten beginnt kann an einem Berechnungsknoten, einem Reduktionsknoten oder einem anderen Tensorknoten enden. Diese Kante kann von einem ersten Kantentyp sein, der eine Programmschleife für eine widerholte Ausführung einer Berechnung definiert. Diese Berechnung ist beispielsweise durch einen Teilgraphen des Graphen definiert, dessen Wurzel der Knoten ist, an dem die Kante des ersten Kantentyps endet. Die Kante kann von einem zweiten Kantentyp sein, der ein für die wiederholte Berechnung in der Programmschleife erforderliches Teilergebnis definiert. In diesem Fall umfasst der Teilgraph wenigstens einen Knoten, der einen Verweis auf das Teilergebnis definiert. Eine Position dieses Knotens in einer Struktur des Teilgraphs definiert eine Reihenfolge für die Berechnung unter Verwendung des Teilergebnisses. Der Verweis kann durch eine zusätzliche Kante eines dritten Kantentyps im Graph repräsentiert werden, der diesen Knoten direkt mit demselben Knoten verbindet, an dem die Kante des zweiten Kantentyps endet. Die Programmschleife kann durch eine Kante eines vierten Kantentyps im Graph repräsentiert werden.
Die Kanten des dritten Kantentyps und des vierten Kantentyps sind im Beispiel dem Knoten als Eigenschaft zugeordnet, an dem sie beginnen. Die Kanten des dritten Typs können durch eine Angabe der Aufwärtsbewegungen und durch Angabe wenigstens einer daran anschließenden Bewegung entlang einer Kante des zweiten Kantentyps ausgehend von diesem Knoten definiert sein. Die Kanten des vierten Typs können durch eine Angabe der Anzahl der Aufwärtsbewegungen im Graph ausgehend von diesem Knoten definiert sein. Aufwärtsbewegung bezeichnet eine Bewegung vom Knoten entlang einer Kante in Richtung auf den Wurzelknoten des Graphs.
Die Kanten des ersten Kantentyps, des zweiten Kantentyps, des dritten Kantentyps und des vierten Kantentyps sind im Beispiel gerichtete Kanten. Gerichtete Kanten eines fünften Kantentyps beginnen bei einem Reduktionsknoten, einem Berechnungsknoten oder einem Eingangsknoten und enden bei einem anderen Knoten.
In dem in Figur 2 dargestellten Graphen werden die Kanten wie folgt dargestellt:
Kanten des ersten Kantentyps und des fünften Kantentyps werden durch Pfeile dargestellt,
Kanten des zweiten Kantentyps werden durch gepunktete Pfeile dargestellt, Kanten des dritten Kantentyps sind durch gestrichelte Pfeile dargestellt,
Kanten des vierten Kantentyps sind durch strichpunktierte Pfeile dargestellt.
Der Graph in Figur 2 stellt eine erste Repräsentation der folgenden Rechenvorschrift Ri; für ein Skalar s und Matritzen Q und K dar: ln Figur 3 ist eine zweite Repräsentation derselben Rechenvorschrift Ri; dargestellt.
Figure imgf000016_0001
Im Beispiel sind Tensorknoten mit Großbuchstaben bezeichnet, wobei eine Dimension für ein Intervall für eine Programmschleife für eine wiederholte Ausführung einer Berechnung beim jeweiligen Tensorknoten in eckigen Klammern [ ] dargestellt ist. Der Wurzelknoten des jeweiligen Graphs ist durch einen Tensorknoten definiert, dem eine der Dimensionen des Ergebnisses zugeordnet ist. Ein Eingangsknoten, mit dem auf eine der Matrizen aus der Rechenvorschrift zugegriffen wird, ist mit demselben Großbuchstaben gekennzeichnet, mit dem die Matrix gekennzeichnet, ist. Jedem der Eingangsknoten ist im Beispiel je ein Zugriffsknoten für je eine Dimension der jeweiligen Matrix zugeordnet wobei die jeweilige Dimension in eckigen Klammern [ ] angegeben ist. Die Größe der jeweiligen Dimension kann, ausgehend davon, dass die Dimension bei null beginnt, als Doppelpunkt gefolgt von einer Zahl, die die Größe angibt, in der eckigen Klammer angegeben sein. Berechnungsknoten, die algebraische Operationen definieren, sind mit dem mathematischen Zeichen versehen, das sie definieren. Im Beispiel wird eine Multiplikation von s mit der Summe S durch einen mit * gekennzeichneten Berechnungsknoten dargestellt. Reduktionsknoten sind mit der Operation bezeichnet, die zur Reduktion eingesetzt wird. Sofern die Reduktion eine algebraische Operation erfordert, kann diese als Eigenschaft dem Reduktionsknoten zugeordnet sein. Im Beispiel ist der Reduktionskonten mit S+ bezeichnet, da es sich um eine Summenbildung handelt.
Bei der Erzeugung von Instruktionen aus dem Graph kann eine Auswertung von Randbedingungen vorgesehen sein. Beispielsweise wird die Reihenfolge der Berechnungen, die durch Kanten des dritten Kantentyps oder des vierten Kantentyps definiert ist, ausgewertet und durch die erzeugten Instruktionen eingehalten. Randbedingungen können als Eigenschaft definiert und einem Knoten zugeordnet sein. Es kann vorgesehen sein, dass eine algebraische Operation, die eine definiert Anordnung der Operanden im Eingang des Speicher 108 erfordert, als Eigenschaft dem Knoten zugeordnet ist, der diese Operation definiert. Diese Eigenschaft wird ausgewertet und durch die erzeugten Instruktionen eingehalten.
Im Beispiel ist ein Muster definiert, das eine Struktur aufweist, die eine vom Hardwarebeschleuniger besonders gut berechenbare Rechenvorschrift definiert. Das Muster definiert die Instruktionen, die besonders gut zu einer bestimmten Hardware des Hardwarebeschleunigers passen. Mit dem im Folgenden beschriebenen Verfahren können die für diese Hardware besonders gut geeigneten Instruktionen erzeugt werden.
Unterschiedliche Hardwarebeschleuniger können unterschiedliche Hardware mit elektrischen Schaltungen umfassen, die Rechenvorschriften einer bestimmten Struktur beschleunigt berechnen können.
Die Knoten des Graphs definieren Operationen oder Operanden zur Ausführung der Rechenvorschrift. Die Kanten definieren eine Reihenfolge der Anwendung von Operationen zur Ausführung der Rechenvorschrift.
Das Verfahren zur Erzeugung der Instruktionen wird im Folgenden mit Bezug auf Figur 4 dargestellt.
In einem Schritt 200 wird eine erste Struktur für einen Graphen bereitgestellt, die wenigstens eine Operation definiert, die von einem Hardwarebeschleuniger ausführbar ist. Beispielsweise wird definiert die erste Struktur eine Anordnung von Knoten und Kanten im Graph.
Verschiedene Möglichkeiten, die erste Struktur bereitzustellen werden im Folgenden angegeben.
In einem Schritt 200 wird eine Rechenvorschrift bereitgestellt.
Anschließend wird in einem Schritt 202 die Zwischenrepräsentation für die Rechenvorschrift bereitgestellt. Anschließend wird in einem Schritt 204 ein gerichteter erster Graph mit Knoten und Kanten bereitgestellt, der die Rechenvorschrift repräsentiert. Im Beispiel hat der erste Graph die Eigenschaft eines Baums.
Im Beispiel wird aus dem Graph für die Zwischenrepräsentation der erste Graph als Baum bestimmt, so dass nur ein Pfad existiert, der jedes Knotenpaar im ersten Graph verbindet. In der Zwischenrepräsentation haben einander zugeordnete Eltern- und Kindknoten bereits diese Eigenschaft. Kanten, die in der Zwischenrepräsentation eine Datenabhängigkeiten definieren, werden im ersten Graph dem dritten Kantentyp zugewiesen. Kanten, die in der Zwischenrepräsentation eine Iteration definieren, werden im ersten Graph dem vierten Kantentyp zugewiesen.
Die Kanten des ersten, des zweiten und des fünften Kantentyps definieren einen Graphen mit Baumstruktur, in dem ein Knoten, der einen Iterator definiert, von einem Knoten, der den Iterator benutzt, durch einen Pfad erreichbar ist, der nur durch gerichtete Kanten des ersten, des zweiten und des fünften Kantentyps erreichbar ist. Die gerichtete Kante des dritten Kantentyps oder des vierten Kantentyps führt zu dem Knoten, der ihn benutzt. Eine Kante des dritten Kantentyps kann durch einen Pfad im Baum entlang des ersten, zweiten und fünften Kantentyps realisiert werden. Der Pfad kann für die Mustererkennung in einem Eingangsknoten gespeichert werden. Eine Kante des vierten Kantentyps kann durch eine Angabe einer Pfadlänge, beispielsweise als Integer, in dem Knoten definiert werden, der den Iterator definiert. Alleine durch eine Angabe dieser Pfadlänge ist der Pfad im Baum ausgehend vom Knoten, der den Iterator verwendet, bis zu dem Knoten, der den Iterator definiert, zurücklegbar.
Diese Pfadlänge ersetzt im Beispiel die Angabe des Knotens, der den Iterator verwendet.
Im Beispiel wird die Pfadlänge in einem Blatt des Baums, d.h. einem Zugriffsknoten, der den Iterator definiert, gespeichert. Der Iterator entspricht beispielsweise einer Dimension, über die ein Tensor, der in einem Tensorknoten definiert ist, der diesen Iterator verwendet, berechnet wird. Der Iterator entspricht beispielsweise einer Dimension, über die eine Reduktion, die in einem Reduktionsknoten definiert ist, der diesen Iterator verwendet, berechnet wird. Im Beispiel wird eine Datenabhängigkeit für eine Vielzahl Programmschleifen oder Verweise in den jeweiligen Blättern des Baums gespeichert.
Abhängig davon wird eine im Folgenden näher beschriebene Datenstruktur definiert, mit der ein Musterabgleich mit einer Vielzahl Instruktionen aus einer Menge Instruktionen erfolgen kann.
Im Beispiel wird dazu eine Wurzel zu Blatt Pfad einer Instruktion als Zeichenfolge von Bezeichnungen definiert. Eine Bezeichnung umfasst den Knotentyp eines Knoten im Pfad oder eine geordnete Liste der Bezeichnungen der Kindknoten, die gemäß der Richtung des gerichteten Pfads geordnet ist.
Es kann vorgesehen sein, die Bezeichnungen aus der oben beschriebenen Definition für die Typen von Knoten mittels einer endlichen Zustandsmaschine für den Zeichenfolgenvergleich bestimmt werden. Dazu kann beispielsweise der Aho-Corasick Algorithmus gemäß Alfred V. Aho and Margaret J. Corasick. 1975. Efficient String Matching: An Aid to Bibliographie Search. Commun. ACM 18, 6 (June 1975), 333-340. https://doi.Org/10.1145/360825.360855 eingesetzt werden.
Der erste Graph definiert erste Instruktionen für die Recheneinrichtung 102 zur Ausführung der Rechenvorschrift.
In einem Schritt 206 wird im ersten Graph wenigstens ein erster Teil mit einer ersten Struktur gesucht. Die erste Struktur ist im Beispiel durch eine erste Zeichenfolge definiert. Dadurch wird das Problem des Musterabgleichs auf ein Problem eines Zeichenfolgenvergleichs der ersten Zeichenfolge mit einer Zeichenfolge, die das Muster repräsentiert, reduziert.
In einem Schritt 208 wird abhängig vom wenigstens einen ersten Teil ein zweiter Teil mit einer zweiten Struktur bestimmt. Die zweite Struktur ist im Beispiel durch eine zweite Zeichenfolge definiert. Die Struktur oder Muster zur Ersetzung sind im Beispiel paarweise definiert. In einem Schritt 210 wird abhängig vom ersten Graph ein gerichteter azyklischer zusammenhängender zweiter Graph mit Knoten und Kanten bestimmt. Im zweiten Graph ist der erste Teil durch den zweiten Teil ersetzt.
Der zweite Graph definiert zweite Instruktionen für die Recheneinrichtung 102 zur Ausführung der Rechenvorschrift.
In einem Schritt 212 wird ein Muster für wenigstens einen Teil eines Graphs bereitgestellt, dessen Knoten und Kanten durch Instruktionen definiert ist, die von der Recheneinrichtung 102 ausführbar sind. Es kann vorgesehen sein, dass von der Recheneinrichtung ausführbare Instruktionen vorgegeben, bestimmt oder empfangen werden. Das Muster kann in diesem Fall abhängig von den ausführbaren Instruktionen bestimmt werden. Im Beispiel wird das Muster durch wenigstens einen Teil eines Graphen repräsentiert, der wie für die Zwischenrepräsentation beschrieben, aus den ausführbaren Instruktionen bestimmt wird und eine Struktur eines Baums aufweist. Das Muster ist eine entsprechende Zeichenfolge definiert. Der Musterabgleich erfolgt durch einen Zeichenfolgenvergleich der ersten Zeichenfolge oder der zweiten Zeichenfolge mit einer Zeichenfolge, die das Muster repräsentiert.
In einem Schritt 214 wird abhängig vom Muster entweder der erste Graph oder der zweite Graph zum Erzeugen von Instruktionen für die Recheneinrichtung 102 ausgewählt.
Der erste Graph und der zweite Graph sind Kandidaten, die mit dem Muster durchsuchbar sind, um einen geeigneten Graphen zur Erzeugung der Instruktionen zur Berechnung der Rechenvorschrift zu bestimmen.
Es kann Vorkommen, dass für den Musterabgleich miteinander in Konflikt stehende Instruktionen für einen Kernel gefunden werden.
Ein Konflikt ist im Beispiel dadurch definiert, dass zwei passende Instruktionen denselben Knoten im Baum eines Graphen für das Muster umfassen. In diesem Fall kann ein Optimierungsproblem abhängig von einer globalen Kostenfunktion definiert sein, die jeder Instruktion eine Kostenfunktion zuordnet. Abhängig von der globalen Kostenfunktion wird in diesem Aspekt eine Lösung des Optimierungsproblems bestimmt, welche das Muster definiert, nach dem die Kandidaten durchsucht werden.
Ein Algorithmus dazu umfasst beispielsweise eine Auswahlfunktion, mit der aus allen möglichen passenden Mustern das Muster ausgewählt wird, das die Lösung des Optimierungsproblems darstellt.
Beispielsweise werden abhängig von einer Liste von in Konflikt stehenden Instruktionen, die während einer Durchquerung des Baums auf einem Ast des Baums von einem Blatt ausgehend gefunden werden, die Instruktionen ausgewählt, die am besten passen.
Die Liste von Instruktionen wird erzeugt, indem der Baum ausgehend von seiner Wurzel einmal durchlaufen wird. Die Stellen an der der Mustersuche-Algorithmus ein Muster gefunden hat, werden der Liste angefügt.
Die Reihenfolge, in der der Baum durchlaufen wird ist beispielsweise: Right-to- Left pre order.
Dies ist ein rekursiver Algorithmus, der in jedem Knoten das folgende macht:
1) Die Daten des aktuellen Knoten werden gelesen
2) Dann wird rekursiv der rechte Teilbaum besucht
3) Dann rekursiv der linke Teilbaum besucht.
Ein Ast wird beispielsweise nicht weiterverfolgt, wenn die Kostenfunktionen einer passenden Instruktion für die globale Kotenfunktion keine Verbesserung gegenüber einer nächstmöglichen passenden Instruktion bewirkt. Für jede für einen aktuellen Knoten passende Instruktion kann eine nächste Instruktion bestimmt werden, die nicht mit dem aktuellen Knoten überlappt.
Sofern diese Instruktion die globale Kostenfunktion verbessert, wird dazu der nächste Knoten bestimmt, der vom aktuellen Knoten aus erreichbar ist. Eine Funktion zur Umsetzung des Algorithmus kann vorsehen, das für Knoten, die keine mögliche Fortsetzung darstellen, ein leerer Wert zurückgegeben wird. Bei der Suche nach dem Muster im ersten Graphen kann es Vorkommen, dass mehrere Muster gefunden werden, die den oder die selben Knoten im ersten Graph bedecken. Das bedeutet, die Muster oder Instruktionen überlappen sich in diesem Knoten oder diesen Knoten. Dies ist nicht zulässig, da jedes gefundene Muster, also jede Instruktion, für sich alleine stehen muss.
Bei mehreren gefunden Mustern wird eine Auswahl für ein Muster getroffen, und das nächste Muster so ausgewählt, dass es nicht mit einem der schon ausgewählten Mustern überlappt.
Für den zweiten Graphen oder andere Kandidaten wird wie für den ersten Graphen beschrieben verfahren.
Es kann vorgesehen sein, eine Programmschleife für eine Rechenvorschrift in eine innere und eine äußere Programmschleife aufzuspalten. Es kann vorgesehen sein, eine Iterationsdomäne der inneren Programmschleife zu limitieren und dadurch eine Arbeitsmenge der inneren Programmschleife zu begrenzen. Es kann vorgesehen sein, wenigstens einen Parameter zu bestimmen, der eine Speicherkachel im Speicher charakterisieren, und der einer Instruktion eine Arbeitsbelastung zuordnet. Ein Tensorknoten beschreibt im Beispiel ein unabhängiges Element dessen Anordnung in einem Programmablauf das Ergebnis nicht beeinflusst. Im Beispiel wird dem Tensorknoten ein Faktor zugeordnet, der während der Codegenerierung verwendet wird, um passende äußere Programmschleifen und Aufrufe für die Instruktion für den Tensorknoten zu bestimmen. Dadurch können global gut geeignete Parameter bestimmt werden, nachdem die Instruktionen abgeglichen wurden.
Durch den Faktor werden Teilergebnisse definiert, die gespeichert werden und in den folgenden Berechnungen verwendet werden. Für jedes Teilergebnis wird daher ein neuer Tensorknoten und ein dazu passender Tensor erzeugt. Durch den Tensorknoten ist der Tensor, in dem das Teilergebnis gespeichert ist, ansprechbar und für eine spätere Verwendung auffindbar.
Die Instruktionen für die Recheneinrichtung 102 werden in einem Schritt 216 entweder abhängig vom ersten Graph erzeugt, wenn dieser im Schritt 214 ausgewählt wurde, oder abhängig vom zweiten Graph erzeugt, wenn dieser im Schritt 214 ausgewählt wurde.
Dadurch werden Teilgraphen gefunden, die einem Suchmuster entsprechen und neue Teilgraphen erzeugt, die Instruktionen definieren, mit denen ein Teilergebnis eines Teils der Rechenvorschrift vollständig bestimmbar ist.
Unterschiedliche Recheneinrichtungen 102 können verschiedene Teilergebnisse mit verschiedener spezialisierter Hardware unterschiedlich schnell oder präzise bestimmen. Das Muster definiert die Instruktionen, die besonders gut zu einer bestimmten Hardware passen. Dadurch können die für diese Hardware besonders gut geeigneten Instruktionen erzeugt werden.
Die erste Struktur kann einen ersten Teilgraphen definieren, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Operanden wenigstens eine Operation in einer ersten Reihenfolge definieren.
In diesem Fall definiert die zweite Struktur beispielsweise einen zweiten Teilgraphen, der durch die Knoten des ersten Teilgraphs definiert ist. Die Kanten des zweiten Teilgraphs definieren für die wenigstens zwei Operanden wenigstens eine Operation in einer zweiten Reihenfolge. Die wenigstens eine Operation kann eine elementweise arithmetische Operation sein.
Die erste Struktur kann, wie in Figur 5 links dargestellt definiert sein. Die zweite Struktur kann wie in Figur 5 rechts dargestellt definiert sein. Die erste Struktur umfasst einen ersten Knoten R[x:10] an dem eine erste Kante beginnt. Die erste Kante endet an einem zweiten Knoten R[y:20] Am zweiten Knoten R[y:20] beginnt eine zweite Kante, die an einem dritten Knoten + endet.
Der dritte Knoten + definiert eine Operation, Addition, deren Operanden einen ersten Teilgraphen, im Beispiel ein Skalar a und einen zweiten Teilgraph N(x,y)*Act(x,y) umfassen. Der zweite Knoten R[y:20] definiert eine erste Programmschleife für eine wiederholte Ausführung der Operation. Der erste Knoten R[x:10] definiert eine zweite Programmschleife für eine wiederholte Ausführung der ersten Programmschleife. Die zweite Struktur umfasst in diesem Fall den ersten Knoten R[x:10], an dem die erste Kante beginnt, die am zweiten Knoten R[y:20] endet. Am zweiten Knoten R[y:20] beginnt die zweite Kante, die am dritten Knoten + endet. Die Operanden für die Operation, die der dritte Knoten + definiert, umfassen den ersten Teilgraph a und einen vierten Knoten T(x,y).
Der vierte Knoten T(x,y) ersetzt den zweiten Teilgraph N(x,y)*Act(x,y) aus dem ersten Teilgraph der ersten Struktur. Die zweite Struktur umfasst eine dritte Kante, die am ersten Knoten R[x:10] beginnt und an einem fünften Knoten T[x:10] endet. Die zweite Struktur umfasst eine vierte Kante, die am fünften Knoten T[x:10] beginnt und an einem sechsten Knoten T[y:20] endet. Der sechste Knoten T[y:20] definiert eine dritte Programmschleife für eine wiederholte Ausführung einer Operation des zweiten Teilgraph N(x,y)*Act(x,y). Der fünfte Knoten T[X:10] definiert eine vierte Programmschleife für eine wiederholte Ausführung der dritten Programmschleife. Eine fünfte Kante, die am vierten Knoten T(x,y) beginnt und am fünften Knoten T[x:10] endet, definiert eine Reihenfolge der Ausführung der vierten Programmschleife vor der zweiten Programmschleife. Dadurch werden Teilgraphen erzeugt, die einen Teil der Rechenvorschrift definieren, mit denen ein Teilergebnis eines Teils der Rechenvorschrift vollständig bestimmbar ist. Die zusätzliche Kante definiert die Reihenfolge der Ausführung, so dass Datenabhängigkeiten zwischen dem Teilergebnis und der Verwendung des Teilergebnisses in der Rechenvorschrift eingehalten werden können.
Die erste Struktur kann, wie in Figur 6 links dargestellt definiert sein. Die zweite Struktur kann wie in Figur 6 rechts dargestellt definiert sein. Die erste Struktur kann einen ersten Knoten R[x:10] umfassen, an dem eine erste Kante beginnt, die an einem zweiten Knoten R[y:20] endet. Am zweiten Knoten R[y:20] beginnt eine zweite Kante, die an einem dritten Knoten T[y:20] endet. Am dritten Knoten T[y:20] beginnt eine dritte Kante, die an einem vierten Knoten T[z:30] endet. Der vierte Knoten T[z:30] definiert eine erste Programmschleife für eine wiederholte Ausführung eines durch einen Teilgraphen definierten Teils der Rechenvorschrift, der dritte Knoten T[y:20] definiert eine zweite Programmschleife für eine wiederholte Ausführung der ersten Programmschleife. Der zweite Knoten R[y:20] definiert eine dritte Programmschleife für eine wiederholte Ausführung der zweiten Programmschleife. Der erste Knoten R[x:10] definiert eine vierte Programmschleife für eine wiederholte Ausführung der dritten Programmschleife.
Am zweiten Knoten R[y:20] beginnt eine vierte Kante, die an einem fünften Knoten S+ endet. Am fünften Knoten S+ beginnt eine fünfte Kante, die an einem sechsten Knoten T(x,y,z) endet. Der sechste Knoten T(x,y,z) definiert ein Teilergebnis, das durch ein Berechnen des durch den Teilgraphen definierten Teils der Rechenvorschrift bestimmbar ist. Der fünfte Knoten S+ definiert eine Operation, die das Teilergebnis verwendet. Eine sechste Kante beginnt am sechsten Knoten T(x,y,z) und endet am dritten Knoten T[y:20] Die sechste Kante definiert eine Reihenfolge der Ausführung der zweiten Programmschleife zur Bestimmung des Teilergebnisses vor einer ersten Ausführung der zweiten Operation in der dritten Programmschleife.
Die zweite Struktur umfasst in diesem Fall den ersten Knoten R[x:10], den zweiten Knoten R[y:20] und den fünften Knoten S+. Die erste Kante beginnt am ersten Knoten R[x:10] und endet am zweiten Knoten R[y:20] Die vierte Kante beginnt am zweiten Knoten R[y:20] und endet am fünften Knoten S+. Der sechste Knoten T(x,y,z) wird durch den Teilgraphen ersetzt.
Die erste Struktur kann einen ersten Teilgraphen definieren, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Dimensionen eines Operanden eine erste Anordnung in einem Speicher der Recheneinrichtung 102 definieren. In diesem Fall kann die zweite Struktur einen zweiten Teilgraphen definieren, der durch die Knoten des ersten Teilgraphs definiert ist, wobei die Kanten des zweiten Teilgraphs für die wenigstens zwei Dimensionen des Operanden eine zweite Anordnung im Speicher definieren.
In einem Aspekt kann die erste Anordnung einen ersten Tensor N für Daten definieren, wobei die zweite Anordnung einen zweiten Tensor NT für die Daten definiert. Der zweite Tensor NT ist durch den transponierten ersten Tensor N definiert. Der zugehörige Eingangsknoten N ist in Figur 7 links für den ersten Tensor N und rechts für den zweiten Tensor NT dargestellt. In der zweiten Anordnung sind die Zugriffsknoten gegenüber der ersten Anordnung vertauscht. In einem andern Aspekt kann die erste Anordnung einen ersten Tensor R für Daten definieren, wobei die zweite Anordnung einen zweiten Tensor RT für die Daten definiert. Der zweite Tensor RT ist durch den transponierten ersten Tensor R definiert. Die erste Anordnung der zugehörigen Tensorknoten R[x:10] und R[y:20] ist in Figur 8 links für den ersten Tensor R dargestellt. Die zweite Anordnung ist in Figur 8 rechts für den zweiten Tensor RT dargestellt. Die Programmschleifen sind in diesem Fall vertauscht angeordnet.
Die erste Anordnung kann gegenüber der zweiten Anordnung mehr Dimensionen umfassen. Die zweite Anordnung wird beispielsweise durch Linearisieren einer Vielzahl von Dimensionen der ersten Anordnung bestimmt.
Die erste Anordnung kann gegenüber der zweiten Anordnung weniger Dimensionen umfassen. Die zweite Anordnung kann in diesem Fall durch Replizieren wenigstens einer Dimension einer Vielzahl von Dimensionen der ersten Anordnung oder durch Hinzufügen einer mit wenigstens einem Wert, insbesondere mit wenigstens einer Null, aufgefüllten Dimension bestimmt werden.
Figur 9 stellt eine Fusion von zwei äußersten Tensorknoten dar. Die erste Struktur kann eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Dimensionen x, y eines Operanden eine erste Anordnung in einem Speicher der Recheneinrichtung 102 definieren.
Die erste Struktur kann, wie in Figur 9 links dargestellt definiert sein. Die zweite Struktur kann wie in Figur 9 rechts dargestellt definiert sein. Die erste Struktur umfasst einen ersten Knoten R[x:10] an dem eine erste Kante des ersten Kantentyps beginnt. Die erste Kante endet an einem zweiten Knoten R[y:20] Am zweiten Knoten R[y:20] beginnt eine zweite Kante des ersten Kantentyps, die an einem dritten Knoten + endet.
Der dritte Knoten + definiert eine erste Operation, im Beispiel eine Addition, deren Operanden einen ersten Teilgraphen, im Beispiel ein Skalar a und einen zweiten Teilgraphen, der einen vierten Knoten T(x,y) umfasst, der ein Teilergebnis definiert. Der zweite Knoten R[y:20] definiert eine erste Programmschleife für eine wiederholte Ausführung der ersten Operation. Der erste Knoten R[x:10] definiert eine zweite Programmschleife für eine wiederholte Ausführung der ersten Programmschleife.
Am ersten Knoten R[x:10] beginnt eine dritte Kante des zweiten Kantentyps, die an einem fünften Knoten T[x:10] endet. Am fünften Knoten T[x:10] beginnt eine vierte Kante des ersten Kantentyps, die an einem sechsten Knoten T[y:20] endet.
Am sechsten Knoten T[y:20] beginnt eine fünfte Kante des ersten Kantentyps, die an einem siebten Knoten * endet. Der siebte Knoten* definiert eine zweite Operation, im Beispiel eine Multiplikation für einen achten Knoten N(x,y) und einen neunten Knoten Act(x,y).
Der sechste Knoten T[y:20] definiert eine dritte Programmschleife für eine wiederholte Ausführung der zweiten Operation. Der fünfte Knoten T[x:10] definiert eine vierte Programmschleife für eine wiederholte Ausführung der dritten Programmschleife.
Eine sechste Kante des dritten Kantentyps beginnt am vierten Knoten T(x,y) und endet am fünften Knoten T[x:10]
Die zweite Struktur umfasst in diesem Fall den ersten Knoten R[x:10], den zweiten Knoten R[y:20], den dritten Knoten +, den ersten Teilgraph und den zweiten Teilgraphen wie für die erste Struktur beschrieben, wobei im zweiten Teilgraph der vierte Knoten T(x,y) durch den sechsten Knoten T[y:20] ersetzt ist. Der siebte Knoten * der achte Knoten N(x,y) und der neunte Knoten Act(x,y) sind wie für die erste Struktur beschrieben angeordnet.
Damit werden die zweite und die vierte Programmschleife fusioniert. Damit wird eine schnellere Wiederverwendung von Teilergebnissen erreicht.
Figur 10 stellt eine Einfügung einer Rechenoperation, mit der ein Teilergebnis bestimmt wird, in einen Teilgraphen dar, der zuvor dieses Teilergebnis verwendete. Die erste Struktur kann eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Dimensionen x, y eines Operanden eine erste Anordnung in einem Speicher der Recheneinrichtung 102 definieren.
Die erste Struktur kann, wie in Figur 10 links dargestellt definiert sein. Die zweite Struktur kann wie in Figur 10 rechts dargestellt definiert sein. Die erste Struktur umfasst einen ersten Knoten R[x:10] an dem eine erste Kante des ersten Kantentyps beginnt. Die erste Kante endet an einem zweiten Knoten R[y:20] Am zweiten Knoten R[y:20] beginnt eine zweite Kante des ersten Kantentyps, die an einem dritten Knoten + endet.
Der dritte Knoten + definiert eine erste Operation, im Beispiel eine Addition, deren Operanden einen ersten Teilgraphen, im Beispiel ein Skalar a und einen zweiten Teilgraphen, der einen vierten Knoten T(x,y) umfasst, der ein Teilergebnis definiert.
Der zweite Knoten R[y:20] definiert eine erste Programmschleife für eine wiederholte Ausführung der ersten Operation. Der erste Knoten R[x:10] definiert eine zweite Programmschleife für eine wiederholte Ausführung der ersten Programmschleife.
Am zweiten Knoten R[y:20] beginnt eine dritte Kante des zweiten Kantentyps, die an einem fünften Knoten T[y:20] endet. Am fünften Knoten T[y:20] beginnt eine vierte Kante des ersten Kantentyps, die an einem sechsten Knoten * endet. Der sechste Knoten* definiert eine zweite Operation, im Beispiel eine Multiplikation für einen siebten Knoten N(x,y) und einen achten Knoten Act(x,y).
Der fünfte Knoten T[y:20] definiert eine dritte Programmschleife für eine wiederholte Ausführung der zweiten Operation.
Eine sechste Kante des dritten Kantentyps beginnt am vierten Knoten T(x,y) und endet am vierten Knoten T[y:20]
Die zweite Struktur umfasst in diesem Fall den ersten Knoten R[x:10], den zweiten Knoten R[y:20], den dritten Knoten +, den ersten Teilgraph und den zweiten Teilgraphen wie für die erste Struktur beschrieben, wobei im zweiten Teilgraph der vierte Knoten T(x,y) durch den fünften Knoten T[y:20] ersetzt ist. Der sechste Knoten *, der siebte Knoten N(x,y) und der achte Knoten Act(x,y) sind wie für die erste Struktur beschrieben angeordnet.
Figur 11 stellt eine Ausgliederung einer Reduktion aus einem Teilgraph in einen anderen Teilgraphen dar. Dadurch entstehet ein neues Zwischenergebnis, das erst bestimmt wird und danach in die Reduktion eingeht.
Die erste Struktur kann, wie in Figur 11 links dargestellt definiert sein. Die zweite Struktur kann wie in Figur 11 rechts dargestellt definiert sein. Die erste Struktur kann einen ersten Knoten R[x:10] umfassen, an dem eine erste Kante beginnt, die an einem zweiten Knoten R[y:20] endet. Am zweiten Knoten R[y:20] beginnt eine zweite Kante, die an einem dritten Knoten S+ endet. Am dritten Knoten S+ beginnt eine dritte Kante, die an einem vierten Knoten * endet. Der vierte Knoten * definiert eine erste Operation, im Beispiel eine Multiplikation für einen fünften Knoten N(x,z) und einen sechsten Knoten Act(z,y) abhängig von wenigstens drei Dimensionen. Im Beispiel sind für den fünften Knoten N(x,z) eine erste Dimension x und eine zweite Dimension y und für den sechsten Knoten Act(z,y) die zweite Dimension und eine dritte Dimension y definiert. Der dritte Knoten S+ definiert eine zweite Operation und eine erste Programmschleife für eine wiederholte Ausführung der ersten Operation. Durch wiederholtes Ausführen der ersten Programmschleife wird eine der wenigstens drei Dimension, im Beispiel die zweite Dimension z reduziert. Am dritten Knoten S+ beginnt eine vierte Kante, die an einem siebten Knoten 0 endet, der einen Startwert für die Reduktion definiert. Der erste Knoten definiert eine zweite Programmschleife, für eine wiederholte Ausführung der zweiten Operation für die erste Dimension x. Eine wiederholte Ausführung über die dritte Dimension y ist damit nicht erforderlich.
Die zweite Struktur definiert in diesem Beispiel den ersten Knoten R[x:10] an dem die erste Kante beginnt, die am zweiten Knoten R[y:20] endet. Am zweiten Knoten R[y:20] beginnt die zweite Kante, die am dritten Knoten S+ endet. Der vierte Knoten * ist in der zweiten Struktur durch einen achten Knoten T(x,y,z) ersetzt, der ein Teilergebnis definiert. Der dritte Knoten S+ definiert die erste Programmschleife und die zweite Operation für den achten Knoten T(x,y,z), d.h. das Teilergebnis, und den siebten Knoten, d.h. den Startwert für die Reduktion. Die zweite Struktur umfasst eine fünfte Kante, die am ersten Knoten R[x:10] beginnt und an einem neunten Knoten T[y:20] endet. Am neunten Knoten T[y:20] beginnt eine sechste Kante, die an einem zehnten Knoten T[y:20] endet. Am zehnten Knoten T[y:20] beginnt eine siebte Kante, die an einem elften Knoten T[z:30] endet. Am elften Knoten T[z:30] beginnt eine achte Kante, die am vierten Knoten * endet. Der vierte Knoten * definiert die erste Operation, im Beispiel die Multiplikation für den fünften Knoten N(x,y,z) und den sechsten Knoten Act(z,y) abhängig von wenigstens drei Dimensionen. Im Beispiel sind für den fünften Knoten N(x,y,z) im Unterschied zur ersten Struktur die erste Dimension x die zweite Dimension z und die dritte Dimension y definiert. Der neunte Knoten T[y:20], der zehnte Knoten T[y:20] und der elfte Knoten T[z:30] definieren eine dritte Programmschleife zur wiederholten Ausführung der ersten Operation. Dadurch wird dasselbe Teilergebnis bestimmt. Eine neunte Kante des dritten Kantentyps beginnt am achten Knoten T(x,y,z) und endet am neunten Knoten T[y:20] Dadurch wird die neue Datenabhängigkeit in der zweiten Struktur dargestellt. Eine zehnte Kante des vierten Kantentyps beginnt am achten Knoten T(x,y,z) und endet am dritten Knoten S+. Dadurch wird die neue Programmschleife in der zweiten Struktur dargestellt.
Die Daten für die Operanden und Operationen sind im Beispiel durch einen Eingang für die Rechenvorschrift oder durch ein Teilergebnis der Rechenvorschrift definiert.
Die erste Struktur kann einen ersten Teilgraphen definieren, der einen ersten Knoten N umfasst, an dem keine Kante beginnt. Der erste Knoten kann einen ersten Speicherbereich für die Recheneinrichtung 102 in wenigstens zwei Dimensionen [i], [j] definieren. Diese erste Struktur umfasst einen zweiten Knoten, der eine Operation für Werte im ersten Speicherbereich definiert. Das Verfahren kann in diesem Fall vorsehen, dass ein zweiter Speicherbereich für die Recheneinrichtung 102 in wenigstens einer der Dimensionen [j] des ersten Speicherbereichs definiert wird. Die zweite Struktur definiert in diesem Fall einen zweiten Teilgraphen, in dem der erste Knoten des ersten Teilgraphs durch einen dritten Knoten N ersetzt ist, der den zweiten Speicherbereich definiert. Die zweite Struktur definiert in diesem Fall für wenigstens eine Dimension des ersten Speicherbereichs, die im zweiten Speicherbereich fehlt, eine Programmschleife, die eine wiederholte Ausführung der Operation mit dem zweiten Operanden über dieser Dimension definiert.
Es kann vorgesehen sein, eine Vielzahl erster Strukturen bereitzustellen, wobei für erste Strukturen, die im ersten Graph gefunden werden, eine Vielzahl zweiter Graphen bestimmt wird. Es kann vorgesehen sein, in der Vielzahl zweiter Graphen nach der Vielzahl erster Strukturen zu suchen. Die Suche kann iterativ wiederholt werden, bis kein weiterer Teilgraph mehr gefunden wird, der dem Suchmuster entspricht.
Der erste Graph und die resultierende Vielzahl zweiter Graphen definiert Kandidaten, die mit dem Muster durchsuchbar sind, um einen geeigneten Graphen zur Erzeugung der Instruktionen zur Berechnung der Rechenvorschrift zu bestimmen. Dies kann beim Verbinden eines Hardwarebeschleunigers oder bei Eingabe einer zuvor unbekannten Rechenvorschrift vor deren Berechnung mit der Recheneinrichtung 102 erfolgen. Dadurch können die richtigen Instruktionen für beliebige Hardwarebeschleuniger und beliebige Rechenvorschriften im Betrieb der Recheneinrichtung 102 erzeugt werden.
Diese Recheneinrichtung 102 kann mit beliebigen Hardwarebeschleunigern betrieben werden, die unabhängig von der Recheneinrichtung selbst hergestellt werden können.
Bei einem künstlichen neuronalen Netzwerk kann die Rechenvorschrift einen Kernel definieren oder umfassen, der das künstliche neuronale Netzwerk definiert.
Es kann vorgesehen sein, zur automatisierten Erzeugung der Graphen eine Datenstruktur vorzusehen, die für einen Knoten abhängig von seinem Knotentyp wie folgt definiert ist. Der Knotentyp ist im Beispiel einer aus der Gruppe Tensorknoten, Reduktionsknoten, Berechnungsknoten, Eingangsknoten, Zugriffsknoten. Beispielhafte Datenstrukturen sind in Figur 12 dargestellt.
Elternknoten bezeichnet im Folgenden einen Knoten, an dem eine Kante beginnt, die an dem Knoten endet, dessen Datenstruktur ein Datenfeld umfasst, das den Elternknoten definiert. Kindknoten bezeichnet im Folgenden einen Knoten, an dem eine Kante beginnt, dessen Datenstruktur ein Datenfeld umfasst, das den Kindknoten definiert. Sofern kein Elternknoten oder kein Kindknoten vorhanden ist, wird dies im Beispiel durch einen leeren Eintrag im entsprechenden Datenfeld definiert.
Der Knotentyp Tensorknoten ist durch eine Datenstruktur 900 definiert, die ein Datenfeld 902 für einen Elternknoten, ein Datenfeld 904 für einen Kindknoten, der mit einer Kante des ersten Kantentyps erreichbar ist, ein Datenfeld 906 für einen Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist, ein Datenfeld 908 für einen Datennutzer und ein Datenfeld 910 für eine Größe wenigstens einer Dimension des Tensors umfasst.
Das Datenfeld 902 für den Elternknoten kann einen anderen Tensorknoten definieren, oder einen leeren Eintrag enthalten.
Das Datenfeld 904 für den Kindknoten, der mit einer Kante des ersten Kantentyps erreichbar ist, kann einen Knoten aus der Gruppe Tensorknoten, Reduktionsknoten, Berechnungsknoten, Eingangsknoten definieren.
Das Datenfeld 906 für den Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist, kann einen anderen Tensorknoten definieren.
Das Datenfeld 908 für den Datennutzer kann einen Eingang definieren, oder einen leeren Eintrag enthalten.
Das Datenfeld 910 für die Größe kann ein Intervall definieren. Im Beispiel umfasst Intervall einen Eintrag für eine obere Grenze der Dimension, eine untere Grenze der Dimension und eine Schrittweite für die wiederholte Ausführung der Programmschleife. Die obere Grenze, die untere Grenze und die Schrittweite können Integer Werte sein.
Der Knotentyp Reduktionsknoten ist durch eine Datenstruktur 912 definiert, die ein Datenfeld 902 für einen Elternknoten, ein Datenfeld 904 für einen Kindknoten der mit einer Kante des ersten Kantentyps erreichbar ist, ein Datenfeld 906 für einen Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist und ein Datenfeld 914 für eine Größe wenigstens einer Dimension für die Reduktion umfasst.
Das Datenfeld 902 für den Elternknoten kann einen Knoten aus der Gruppe Tensorknoten, Reduktionsknoten, Berechnungsknoten definieren.
Das Datenfeld 904 für den Kindknoten, der mit einer Kante des ersten Kantentyps erreichbar ist, kann einen Eingangsknoten definieren.
Das Datenfeld 906 für den Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist, kann einen Knoten aus der Gruppe Reduktionsknoten, Berechnungsknoten, Eingangsknoten definieren.
Das Datenfeld 914 für die Größe kann ein Intervall definieren. Im Beispiel umfasst Intervall einen Eintrag für eine obere Grenze der Dimension, eine untere Grenze der Dimension und eine Schrittweite für die wiederholte Ausführung der Berechnung für die Reduktion. Die obere Grenze, die untere Grenze und die Schrittweite können Integer Werte sein.
Der Knotentyp Berechnungsknoten ist durch eine Datenstruktur 916 definiert, die ein Datenfeld 902 für einen Elternknoten, ein Datenfeld 904 für einen Kindknoten der mit einer Kante des ersten Kantentyps erreichbar ist, ein Datenfeld 906 für einen Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist und ein Datenfeld 918 für eine Operation umfasst.
Das Datenfeld 902 für den Elternknoten kann einen Knoten aus der Gruppe Tensorknoten, Reduktionsknoten, Berechnungsknoten definieren.
Das Datenfeld 904 für den Kindknoten, der mit einer Kante des ersten Kantentyps erreichbar ist, kann einen Knoten aus der Gruppe Reduktionsknoten, Berechnungsknoten, Eingangsknoten definieren.
Das Datenfeld 906 für den Kindknoten, der mit einer Kante des zweiten Kantentyps erreichbar ist, kann einen Knoten aus der Gruppe Reduktionsknoten, Berechnungsknoten, Eingangsknoten definieren. Das Datenfeld 918 für die Operation kann eine arithmetische Operation definieren, z.B. Addition +, Subtraktion Multiplikation *, Division : oder auch andere unäre und binäre Operationen, z.B. Sinus, Cosinus, Tangens, Maximum (max), Minimum (min), Exponentialfunktion, oder Bitshift.
Der Knotentyp Eingangsknoten ist durch eine Datenstruktur 920 definiert, die ein Datenfeld 902 für einen Elternknoten, ein Datenfeld 922 für eine Abhängigkeit oder Reihenfolge aufgrund einer Kante des dritten Kantentyps und ein Datenfeld 924 für einen oder mehrere Kindknoten umfasst.
Das Datenfeld 902 für den Elternknoten kann einen Knoten aus der Gruppe Tensorknoten, Reduktionsknoten, Berechnungsknoten definieren.
Das Datenfeld 922 für eine Abhängigkeit aufgrund einer Kante des dritten Kantentyps kann einen Tensorknoten definieren, zu dem die Kante führt, oder einen leeren Eintrag enthalten.
Das Datenfeld 924 für den einen oder die mehreren Kindknoten kann eine Liste mit einem oder mehreren Zugriffsknoten umfassen.
Der Knotentyp Zugriffsknoten ist durch eine Datenstruktur 926 definiert, die ein Datenfeld 902 für einen Elternknoten, ein Datenfeld 928 für einen Wertetyp und ein Datenfeld 924 für einen oder mehrere Kindknoten umfasst.
Das Datenfeld 902 für den Elternknoten kann einen Knoten aus der Gruppe Eingangsknoten oder Zugriffsknoten definieren.
Das Datenfeld 928 für den Wertetyp kann einen Typ für die Daten, die der Zugriffsknoten aus dem Speicher referenziert definieren. Der Typ kann Iterator, Operation oder skalare Konstante sein.
Das Datenfeld 924 für den Kindknoten kann eine Liste mit einem oder mehreren Zugriffsknoten umfassen oder einen leeren Eintrag.
Die Zugriffsknoten können eine der Dimensionen eines Vektors, Tensors oder einer Matrix im Speicher 108 definieren. Der Zugriff auf mehrere Dimensionen ist kann durch eine Verkettung von Zugriffsknoten definiert sein, wobei ein erster Zugriffsknoten eine erste Dimension und ein letzter Zugriffsknoten in der Verkettung eine höchste Dimension definiert. Dabei wird in einem Eingangsknoten ein Zugriffsknoten für die erste Dimension als Kindknoten definiert. Der Zugriffsknoten für die erste Dimension definiert als Kindknoten einen Zugriffsknoten für die zweite Dimension. Dies wird fortgesetzt bis ein Zugriffsknoten den letzten Zugriffsknoten für die höchste Dimension definiert. Der letzte Zugriffknoten definiert für den Kindknoten den leeren Eintrag. Die Instruktionen für die Mustersuche können durch ein in Alfred V. Aho and
Margaret J. Corasick. 1975. Efficient String Matching: An Aid to Bibliographie Search. Commun. ACM 18, 6 (June 1975), 333-340. https://doi.org/10.1145/360825.360855 beschriebenes Vorgehen bestimmt werden.
Die Mustererkennung kann durch einen in Christoph M. Hoffmann and Michael J. O’Donnell. 1982. Pattern Matching in Trees. J. ACM 29, 1 (Jan. 1982), 68-95. https://doi.Org/10.1145/322290.322295 beschriebenen Suchvorgang erfolgen.

Claims

Ansprüche
1. Computerimplementiertes Verfahren zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift, dadurch gekennzeichnet, dass ein gerichteter erster Graph mit Knoten und Kanten bereitgestellt wird (204), der erste Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei im ersten Graph wenigstens ein erster Teil mit einer ersten Struktur gesucht wird (206), wobei abhängig vom wenigstens einen ersten Teil ein zweiter Teil mit einer zweiten Struktur bestimmt wird (208), wobei abhängig vom ersten Graph ein gerichteter zweiter Graph mit Knoten und Kanten bestimmt wird (210), wobei im zweiten Graph der erste Teil durch den zweiten Teil ersetzt ist, wobei der zweite Graph zweite Instruktionen für die Recheneinrichtung zur Ausführung der Rechenvorschrift definiert, wobei ein Muster für wenigstens einen Teil eines Graphs bereitgestellt wird (212), dessen Knoten und Kanten durch Instruktionen definiert ist, die von der Recheneinrichtung ausführbar sind, wobei die Instruktionen für die Recheneinrichtung entweder abhängig vom ersten Graph oder abhängig vom zweiten Graph erzeugt werden (216), und wobei abhängig vom Muster der erste Graph oder der zweite Graph zum Erzeugen von Instruktionen für die Recheneinrichtung ausgewählt wird (214).
2. Verfahren nach Anspruch 1, dadurch gekennzeichnet, dass abhängig von der Rechenvorschrift, ein Graph bereitgestellt wird (202), der einen Knoten umfasst, der einen Iterator für eine Operation zur Ausführung der Rechenvorschrift definiert, wobei eine Länge eines Pfads im Graph zwischen einem Knoten, der den Iterator verwendet und dem Knoten, der den Iterator definiert, bestimmt wird, wobei im Knoten, der den Iterator verwendet ein Verweis auf den Knoten, der den Iterator definiert, durch eine Angabe ersetzt wird, die die Länge des Pfads umfasst, und wobei der gerichtete erste Graph abhängig von dem Knoten, der die Länge des Pfads umfasst, bestimmt wird.
3. Verfahren nach Anspruch 2, dadurch gekennzeichnet, dass die erste Struktur einen ersten Teilgraph definiert, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Operanden wenigstens eine Operation in einer ersten Reihenfolge definieren, wobei die zweite Struktur einen zweiten Teilgraph definiert, der durch die Knoten des ersten Teilgraphs definiert ist, wobei die Kanten des zweiten Teilgraphs für die wenigstens zwei Operanden wenigstens eine Operation in einer zweiten Reihenfolge definieren, wobei die wenigstens eine Operation eine elementweise Operation definiert.
4. Verfahren nach einem der Ansprüche 1 bis 3, dadurch gekennzeichnet, dass die erste Struktur durch eine erste Zeichenfolge definiert ist, die einen Pfad im ersten Graph definiert, wobei die zweite Struktur durch eine zweite Zeichenfolge definiert ist, die einen Pfad im zweiten Graph definiert.
5. Verfahren nach Anspruch 4, dadurch gekennzeichnet, dass die erste Zeichenfolge und/oder die zweite Zeichenfolge eine geordnete Liste von Bezeichnungen für Knoten im Pfad umfasst, die den Pfad definiert.
6. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass die erste Struktur einen ersten Teilgraph definiert, der eine Mehrzahl Knoten und Kanten umfasst, die für wenigstens zwei Dimensionen eines Operanden eine erste Anordnung in einem Speicher der Recheneinrichtung definieren, wobei die zweite Struktur einen zweiten Teilgraph definiert, der durch die Knoten des ersten Teilgraphs definiert ist, wobei die Kanten des zweiten Teilgraphs für die wenigstens zwei Dimensionen des Operanden eine zweite Anordnung im Speicher definieren.
7. Verfahren nach Anspruch 6, dadurch gekennzeichnet, dass die erste Anordnung einen ersten Tensor für Daten definiert, wobei die zweite Anordnung einen zweiten Tensor für die Daten definiert, wobei der zweite Tensor durch den transponierten ersten Tensor definiert ist.
8. Verfahren nach Anspruch 6 oder 7, dadurch gekennzeichnet, dass die erste Anordnung gegenüber der zweiten Anordnung mehr Dimensionen umfasst, wobei die zweite Anordnung durch Linearisieren einer Vielzahl von Dimensionen der ersten Anordnung bestimmt wird.
9. Verfahren nach Anspruch 6 oder 7, dadurch gekennzeichnet, dass die erste Anordnung gegenüber der zweiten Anordnung weniger Dimensionen umfasst, wobei die zweite Anordnung durch Replizieren wenigstens einer Dimension einer Vielzahl von Dimensionen der ersten Anordnung oder durch Hinzufügen einer mit wenigstens einem Wert, insbesondere mit wenigstens einer Null, aufgefüllten Dimension bestimmt wird.
10. Verfahren nach einem der Ansprüche 7 bis 9, dadurch gekennzeichnet, dass die Daten durch einen Eingang für die Rechenvorschrift oder durch ein Teilergebnis der Rechenvorschrift definiert sind.
11. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass die erste Struktur einen ersten Teilgraph definiert, der einen ersten Knoten umfasst, an dem keine Kante beginnt, wobei der erste Knoten einen ersten Speicherbereich für die Recheneinrichtung in wenigstens zwei Dimensionen definiert, wobei die erste Struktur einen zweiten Knoten umfasst, der eine Operation für Werte im ersten Speicherbereich definiert, wobei ein zweiter Speicherbereich für die Recheneinrichtung in wenigstens einer der Dimensionen des ersten Speicherbereichs definiert wird, wobei die zweite Struktur einen zweiten Teilgraph definiert, in dem der erste Knoten des ersten Teilgraphs durch einen dritten Knoten ersetzt ist, der den zweiten Speicherbereich definiert, wobei die zweite Struktur für wenigstens eine Dimension des ersten Speicherbereichs, die im zweiten Speicherbereich fehlt, eine Programmschleife definiert, die eine wiederholte Ausführung der Operation mit dem zweiten Operanden über dieser Dimension definiert.
12. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass eine Vielzahl erster Strukturen bereitgestellt wird, wobei für erste Strukturen, die im ersten Graph gefunden werden, eine Vielzahl zweiter Graphen bestimmt wird, wobei in der Vielzahl zweiter Graphen nach der Vielzahl erster Strukturen gesucht wird.
13. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass von der Recheneinrichtung ausführbare Instruktionen vorgegeben, bestimmt oder empfangen werden, wobei das Muster abhängig von den ausführbaren Instruktionen bestimmt wird.
14. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass aus einer Vielzahl Datenstrukturen für Knoten des ersten Graphs eine Datenstruktur für einen Knoten des ersten Graphs bestimmt wird, die ein Datenfeld umfasst, das eine Operation definiert, die auf andere Knoten anzuwenden ist, wobei eine Datenstruktur für einen Knoten des zweiten Graphs mit derselben Datenstruktur bestimmt wird, wobei ein Datenfeld, das einen Knoten definiert, auf den die Operation anzuwenden ist, durch ein Datenfeld ersetzt wird, in dem ein anderer Knoten definiert ist, auf den die Operation anzuwenden ist, wobei der andere Knoten entweder in einem anderen Datenfeld der Datenstruktur für den Knoten definiert ist, oder wobei der andere Knoten in einem Datenfeld einer Datenstruktur eines weiteren Knotens definiert ist, auf den ein Datenfeld aus der Datenstruktur des Knotens des ersten Graphs verweist.
15. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass aus einer Vielzahl Datenstrukturen für Knoten des ersten Graphs eine Datenstruktur für einen Knoten des ersten Graphs bestimmt wird, die ein Datenfeld umfasst, das eine Liste mit anderen Knoten definiert, wobei eine Datenstruktur für einen Knoten des zweiten Graphs mit derselben Datenstruktur bestimmt wird, wobei das Datenfeld, das die Liste definiert, durch ein Datenfeld ersetzt wird, in dem ein erster Eintrag aus der Liste mit einem zweiten Eintrag aus der Liste vertauscht ist.
16. Verfahren nach einem der vorherigen Ansprüche, dadurch gekennzeichnet, dass wenigstens ein Knoten bestimmt wird, der eine Programmschleife zur Bestimmung eines Ergebnis definiert, wobei dem Knoten ein Parameter zugeordnet wird, der eine Speicherkachel im Speicher charakterisiert, wobei abhängig vom Parameter eine erste Programmschleife und eine zweite Programmschleife bestimmt werden, wobei die erste Programmschleife wenigstens eine Instruktion zur Bestimmung des Ergebnis und eine Instruktion für einen Aufruf der zweiten Programmschleife umfasst, mit der ein Teilergebnis dafür bestimmbar ist.
17. Vorrichtung zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift, dadurch gekennzeichnet, dass die Vorrichtung ausgebildet ist, das Verfahren nach einem der vorherigen Ansprüche auszuführen.
18. Datenstruktur zum Erzeugen von Instruktionen für eine Recheneinrichtung (102) zur Ausführung einer Rechenvorschrift, dadurch gekennzeichnet, dass die Datenstruktur für eine Knoten eines Graphs umfasst: ein erstes Datenfeld (902) für einen Elternknoten des Knotens im Graph, wenigstens ein zweites Datenfeld (904; 906; 924) für einen Kindknoten des Knotens im Graph und wenigstens ein drittes Datenfeld (908, 910; 914; 918; 922; 928) das eine Operation oder einen Operanden der Rechenvorschrift charakterisiert.
19. Datenstruktur nach Anspruch 18, dadurch gekennzeichnet, dass das wenigstens eine dritte Datenfeld einen Datennutzer (908), eine Größe (910, 914) wenigstens einer Dimension für die Berechnung, eine arithmetische Operation (918), eine Abhängigkeit oder Reihenfolge (922) für die Berechnung oder einen Wertetyp (928) definiert.
PCT/EP2021/059682 2020-05-14 2021-04-14 Vorrichtung und verfahren zum erzeugen von instruktionen für eine recheneinrichtung zur ausführung einer rechenvorschrift WO2021228483A1 (de)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US17/920,862 US20230244745A1 (en) 2020-05-14 2021-04-14 Device and method to generate instructions for a computing device for executing a computational algorithm
CN202180034739.2A CN115485663A (zh) 2020-05-14 2021-04-14 为执行计算规则的计算装置产生指令的设备和方法

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102020206112.2 2020-05-14
DE102020206112.2A DE102020206112A1 (de) 2020-05-14 2020-05-14 Vorrichtung und Verfahren zum Erzeugen von Instruktionen für eine Recheneinrichtung zur Ausführung einer Rechenvorschrift

Publications (1)

Publication Number Publication Date
WO2021228483A1 true WO2021228483A1 (de) 2021-11-18

Family

ID=75562738

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/EP2021/059682 WO2021228483A1 (de) 2020-05-14 2021-04-14 Vorrichtung und verfahren zum erzeugen von instruktionen für eine recheneinrichtung zur ausführung einer rechenvorschrift

Country Status (4)

Country Link
US (1) US20230244745A1 (de)
CN (1) CN115485663A (de)
DE (1) DE102020206112A1 (de)
WO (1) WO2021228483A1 (de)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115599442A (zh) * 2022-12-14 2023-01-13 成都登临科技有限公司（Cn） 一种ai芯片、电子设备及张量处理方法

Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20050257194A1 (en) * 2004-05-14 2005-11-17 National Instruments Corporation Graphical data flow programming environment with first model of computation that includes a structure supporting second model of computation
US8549529B1 (en) * 2009-05-29 2013-10-01 Adobe Systems Incorporated System and method for executing multiple functions execution by generating multiple execution graphs using determined available resources, selecting one of the multiple execution graphs based on estimated cost and compiling the selected execution graph

Patent Citations (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20050257194A1 (en) * 2004-05-14 2005-11-17 National Instruments Corporation Graphical data flow programming environment with first model of computation that includes a structure supporting second model of computation
US8549529B1 (en) * 2009-05-29 2013-10-01 Adobe Systems Incorporated System and method for executing multiple functions execution by generating multiple execution graphs using determined available resources, selecting one of the multiple execution graphs based on estimated cost and compiling the selected execution graph

Non-Patent Citations (4)

* Cited by examiner, † Cited by third party
Title
ALFRED V. AHOMARGARET J. CORASICK: "Efficient String Matching: An Aid to Bibliographic Search. Commun.", vol. 18, June 1975, ACM, pages: 333 - 340
CHRISTOPH M. HOFFMANNMICHAEL J. O'DONNELL.: "Pattern Matching in Trees. J.", vol. 29, January 1982, ACM, pages: 68 - 95
M. SOTOUDEHA. VENKATM. ANDERSONE. GEORGANASA. HEINECKEJ. KNIGH, ISA MAPPER: A COMPUTE AND HARDWARE AGNOSTIC DEEP LEARNINGCOMPILER, Retrieved from the Internet <URL:https://dl.acm.org/doi/10.1145/3310273.3321559>
TIANQI CHENTHIERRY MOREAUZIHENG JIANGHAICHEN SHENEDDIE Q. YANLEYUAN WANGYUWEI HULUIS CEZECARLOS GUESTRINARVIND KRISHNAMURTHY: "TVM: End-to-End Optimization Stack for Deep Learning", CORR ABS/1802.04799 (2018). ARXIV: 1802.04799, 2018, pages 20180000, Retrieved from the Internet <URL:http://arxiv.org/abs/1802.04799>

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115599442A (zh) * 2022-12-14 2023-01-13 成都登临科技有限公司（Cn） 一种ai芯片、电子设备及张量处理方法
CN115599442B (zh) * 2022-12-14 2023-03-10 成都登临科技有限公司 一种ai芯片、电子设备及张量处理方法

Also Published As

Publication number Publication date
DE102020206112A1 (de) 2021-11-18
CN115485663A (zh) 2022-12-16
US20230244745A1 (en) 2023-08-03

Similar Documents

Publication Publication Date Title
DE102018111905A1 (de) Domänenspezifische Sprache zur Erzeugung rekurrenter neuronaler Netzarchitekturen
Meijer et al. Merging monads and folds for functional programming
WO1994022079A1 (de) Verfahren zur maschinellen erzeugung von nebenläufig bearbeitbaren befehlsgruppen aus einem programm für superskalare mikroprozessoren
DE4334294C1 (de) Prozessor für Zeichenketten variabler Länge
DE19934424A1 (de) Verfahren, Vorrichtung und Computer-Programm-Produkt zur Optimierung von Registern in einem Stapel unter Verwendung eines Register-Zuordners
WO2021228483A1 (de) Vorrichtung und verfahren zum erzeugen von instruktionen für eine recheneinrichtung zur ausführung einer rechenvorschrift
EP4000010A1 (de) Vorrichtung und computerimplementiertes verfahren für die verarbeitung digitaler sensordaten und trainingsverfahren dafür
DE10048478C2 (de) Verfahren zum Zugriff auf eine Speichereinheit bei der Suche nach Teilzeichenfolgen
DE3507605A1 (de) Schleifensteuersystem fuer digitale verarbeitungseinrichtungen
EP3736749A1 (de) Verfahren und vorrichtung zur ansteuerung eines geräts mit einem datensatz
DD294115A5 (de) Vorrichtung und verfahren zur signalverarbeitung
DE2425380A1 (de) Verfahren und datenverarbeitungsanlage zur parallelen ausfuehrung von verarbeitungsoperationen
EP1068580B1 (de) Verfahren zum vergleich elektrischer schaltungen
DE60311918T2 (de) Methode und Apparat zur Programmkodekonvertierung zum Vermeiden von Interlocking
DE102008058016A1 (de) System und Verfahren zur rechnerbasierten Analyse großer Datenmengen
DE2613703C2 (de) Schaltungsanordnung zum Übersetzen von Programmtexten
EP0603228B1 (de) Verfahren zum suchen nach einem mit einem suchobjekt identischen oder ähnlichen objekt in einer objektbibliothek----------------
EP4055472B1 (de) Verfahren zur datenmigration eines zeigerelements im zuge einer datenmigration eines programmzustands eines steuerprogramms eines automatisierungssystems
EP3385834A1 (de) Hardwaretreiber für effiziente arithmetik
EP3531302A1 (de) Computerimplementiertes verfahren zum suchen von antworten
WO2006106152A2 (de) Computerimplementiertes verfahren zum automatischen wissensbasierten erzeugen von anwenderrelevanten daten
DE3627204C2 (de) Digitales Computersystem mit einem Expertensystem
DE112021004637T5 (de) Transformieren von operationen eines computerprogramms zur ausführung in einer datenbank
DE102004020873A1 (de) System und Verfahren zum Bestimmen von anwendbaren Konfigurationsinformationen zur Verwendung bei einer Analyse eines computergestützten Entwurfs
EP3828790A1 (de) Verfahren zur herstellung eines, aus einer produktmenge aufgrund eines auswahlkriteriums ausgewählten produkts, sowie produktionssystem hierfür

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 21719583

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 21719583

Country of ref document: EP

Kind code of ref document: A1