Method of calculation based on data flow graph and related device

Abstract

Embodiments of this application provide a method of calculation based on a data flow graph (DFG) and a dataflow microprocessor. The method includes: obtaining a first DFG, wherein the first DFG comprises a number of operators and data transmitted between the number of operators, the first DFG runs on the dataflow microprocessor; optimizing, according to a connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to a second DFG, wherein the second DFG runs on the dataflow microprocesso; and executing the second DFG.. The proposed technique makes it possible to improve the efficiency of dataflow microprocessor.

Description

METHOD OF CALCULATION BASED ON DATA FLOW GRAPH AND RELATED DEVICETECHNICAL FIELD

[0001] Embodiments of the present application relate to the field of data processing, and more particularly, to a method of calculation based on a data flow graph (DFG) , and a related device for calculation based on the DFG.BACKGROUND

[0002] A data flow graph (DFG) is a graph which represents data dependencies between a number of operations, the number of operations are the software running in dataflow microprocessor . An operator is a node that represents data transformation or computation, and has one or more input ports and one or more output ports, data flows from the input ports to the output ports, and the operator performs some transformation on the data as the data flows.

[0003] To our best knowledge, one of the main issues of dataflow microprocessor is the data, which repeatedly moves back and forth between the dataflow microprocessor and RAM, leading to large latency and efficiency losses.

[0004] Therefore, how to improve the efficiency of dataflow microprocessor is a challenge.SUMMARY

[0005] Embodiments of the present application provide a method of calculation based on a data flow graph (DFG) and a dataflow microprocessor. The technical solution may reduce the amount of work in the dataflow microprocessor, thereby improving the efficiency of dataflow microprocessors .

[0006] According to a first aspect, an embodiment of this application provides a method of calculation based on a DFG, where the method is applied to a dataflow microprocessor, the method includes:

[0007] obtaining a first DFG, wherein the first DFG comprises a number of operators and data transmitted between the number of operators, the first DFG runs on the dataflow microprocessor;

[0008] optimizing, according to a connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to a second DFG, wherein the second DFG runs on the dataflow microprocesso; and

[0009] executing the second DFG.

[0010] According to the method above, based on the connection relationship of the operators in the first DFG and / or the data transmitted between the operators, the first DFG running in the dataflow microprocessor is optimized to obtain the second DFG, which is then run in the dataflow microprocessor. Due to the optimization of the second DFG compared to the first DFG, it can improve the execution efficiency of the dataflow microprocessor and also reduce the latency of the dataflow microprocessor.

[0011] In a possible design, where optimizing, according to the connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to the second DFG includes: optimizing, by reducing the number of round-trips between the operators and a random access memory (RAM) in the first DFG, the first DFG to the second DFG.

[0012] According to the method above, compared to the first DFG, the second DFG reduces unnecessary round-trips between the operators in the first DFG and RAM, thereby avoiding unnecessary interaction between the dataflow microprocessor and the RAM, and improving the execution efficiency of the dataflow microprocessor.

[0013] In a possible design, where the first DFG includes a first operator, a second operator, a third operator and a fourth operator, where the first operator outputs first data and sends the first data to the third operator, the third operator writes the first data into the RAM, and the fourth operator retrieves the first data from the RAM and sends the first data to the second operator, and the second DFG includes the first operator and the second operator, where the first operator in the second DFG outputs the first data and sends the first data to the second operator in the second DFG directly.

[0014] According to the method above, compared to the first DFG, the second DFG reduces the number of operators, thereby improving the execution efficiency of the dataflow microprocessor and also reduce the latency of the dataflow microprocessor.

[0015] In a possible design, where the first DFG also includes multiple fifth operators, where the multiple fifth operators respectively obtain second data from the second operator and send the second data to the RAM, and the second DFG also includes one of the fifth operators, where the one fifth operator in the second DFG obtains the second data from the second operator in the second DFG and sends the second data to the RAM.

[0016] In a possible design, where optimizing, according to the connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to the second DFG includes: optimizing, by calculating the data transmitted between the operators in the first DFG, the first DFG to the second DFG.

[0017] In a possible design, where the first DFG also includes a sixth operator, the first operator in the first DFG also sends the first data to the sixth operator in the first DFG, the sixth operator in the first DFG obtains third data based on the first data, and sends the third data to the third operator in the first DFG, the third operator in the first DFG also writes the third data into  the RAM, the fourth operator in the first DFG also retrieves the third data from the RAM and sends the third data to the second operator in the first DFG, and the first operator in the second DFG also obtains the third data based on the first data, and sends the third data to the second operator in the second DFG.

[0018] In a possible design, where the sixth operator in the first DFG is a decrementor.

[0019] In a possible design, where the method is applied to a distribution advisor (DA) in the dataflow microprocessor.

[0020] According to a second aspect, an embodiment of this application provides a dataflow microprocessor, and the dataflow microprocessor has function of implementing the method in the first aspect. The function may be implemented by hardware, or may be implemented by hardware executing corresponding software. The hardware or the software includes one or more modules corresponding to the function.

[0021] According to a third aspect, an embodiment of this application provides a computer readable storage medium including instructions. When the instructions are run on a computer, the computer is enabled to perform the method in the first aspect or any possible design of the first aspect.

[0022] According to a fourth aspect, an embodiment of this application provides a computing device, including a processor, a memory, and a communications interface. The processor is connected to the memory and the communications interface. The memory is configured to store instructions, the processor is configured to execute the instructions, and the communications interface is configured to communicate with another network element under control of the processor. When the processor executes the instructions stored in the memory, the processor is enabled to perform the method in the first aspect or any possible design of the first aspect.

[0023] According to a fifth aspect, an embodiment of this application provides a computing device cluster, including at least one computing device, where the computing device includes a processor and a memory coupled with the processor, where the memory is configured to store a computer program, and the processor is configured to invoke and run the computer program stored in the memory, so that the computing device executes the method in the first aspect or any possible design of the first aspect.

[0024] According to a sixth aspect, a chip system is provided, where the chip system includes a memory and a processor, the memory is configured to store a computer program, and the processor is configured to invoke the computer program from the memory and run the computer program, so that a server on which a chip is disposed performs the method in the first aspect or any possible design of the first aspect.

[0025] According to a seventh aspect, a computer program product is provided, where when the computer program product is run on a server, the server is enabled to perform the method in the first aspect or any possible design of the first aspect.DESCRIPTION OF DRAWINGS

[0026] One or more embodiments are exemplarily illustrated by corresponding accompanying drawings, and these exemplary illustrations and accompanying drawings constitute no limitation on the embodiments. Elements with the same reference numerals in the accompanying drawings are illustrated as similar elements, and the drawings are not limited to scale, in which:

[0027] FIG. 1 shows a pseudo-random number generator implemented in C++.

[0028] FIG. 2 shows a pseudo-random number generator implemented in EO.

[0029] FIG. 3 shows a diagram representing ownership relationships between objects in the EO program of FIG. 2.

[0030] FIG. 4 shows a data flow graph (DFG) for the project of FIG. 2.

[0031] FIG. 5 shows a data flow timeline (DFT) for the DFG of FIG. 4.

[0032] FIG. 6 is a schematic diagram of a method of calculation based on a data flow graph (DFG) according to an embodiment of this application.

[0033] FIG. 7 shows a schematic diagram that resembles the original architecture of a dataflow machine.

[0034] FIG. 8 shows a DFT of evaluation of the DFG in FIG. 6.

[0035] FIG. 9 shows an architecture of a dataflow microprocessor.

[0036] FIG. 10 shows an activity diagram of the workflow performed by a DA.

[0037] FIG. 11 shows another architecture of a dataflow microprocessor.

[0038] FIG. 12 shows an optimization of a rewriting rule of Eq. (1) demonstrated visually.

[0039] FIG. 13 shows a DFT of evaluation of the DFG in FIG. 4 on a simulator with an enabled module that reproduces the functionality of the DA.

[0040] FIG. 14 shows a sample DFG for a dataflow program in which an edge from v1 to v3 operator may be removed.

[0041] FIG. 15 shows a sample DFG for a dataflow program in which data is sent only to one writer w1.

[0042] FIG. 16 is a schematic block diagram of a dataflow microprocessor according to an embodiment of this application.

[0043] FIG. 17 is a schematic block diagram of a computing device according to an embodiment of this application.DESCRIPTION OF EMBODIMENTS

[0044] The following clearly and completely describes the technical solutions in the embodiments of the present application with reference to the accompanying drawings. Apparently, the described embodiments are merely some but not all of the  embodiments of the present application. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present application without creative efforts shall fall within the protection scope of the present application.

[0045] In the specification, claims, and accompanying drawings of the present application, the term “include” and any other variants of the term mean to cover the non-exclusive inclusion. For example, a process, a method, a system, a product, or a device that includes a series of steps or units is not limited to the listed steps or units, but optionally further includes an unlisted step or unit, or optionally further includes another inherent step or unit of the process, the method, the system, the product, or the device.

[0046] This application will present various aspects, embodiments or features in the context of a system including a plurality of devices, components, modules, and the like. It is to be understood and appreciated that various systems may include additional devices, components, modules, etc., and / or may not include all of the devices, components, modules, etc. discussed in connection with the figures. In addition, combinations of these schemes can also be used.

[0047] In addition, in the embodiments of the present application, words such as “exemplary” and “for example” are used to represent examples or illustrations. Any embodiment or design described in this application as “exemplary” should not be construed as a preferred or advantageous embodiment over other embodiments or designs. Rather, the use of the word example is intended to present a concept in a concrete way.

[0048] In this application, “relevant” and “corresponding” can sometimes be used interchangeably, and it should be noted that, when the difference is not emphasized, the meanings to be expressed are the same.

[0049] The service scenarios described in the embodiments of the present application are for the purpose of illustrating the technical solutions of the embodiments of the present application more clearly, and do not constitute a limitation on the technical solutions provided by the embodiments of the present application. In spite of the evolution of an architecture and the emergence of new business scenarios, the technical solutions provided in the embodiments of the present application are also applicable to solving similar technical problems.

[0050] For the convenience of description, the following will explain several concepts involved in the embodiment of the application.

[0051] A data flow graph (DFG) is a graph which represents data dependencies between a number of operations, the number of operations are the software running in dataflow microprocessor.

[0052] A surging object di-graph (SODG) is a graphical representation of an object-oriented program, where objects are vertices and their attributes are edges.

[0053] A data flow timeline (DFT) is a textual chronological representation of evaluation of a DFG.

[0054] An operator is a node that represents data transformation or computation having one or more input ports and one or more output ports, data flows from the input ports to the output ports, and the operator performs some transformation on the data as the data flows.

[0055] An instruction cell (IC) is a small unit of memory that stores an instruction and its operands; and it is responsible for controlling the execution of the instruction, and it also provides the operands to functional units that perform the actual computation.

[0056] An operation unit (OU) is a computational unit that performs a specific operation on the data in an IC.

[0057] A distribution advisor (DA) is a hardware component of a dataflow microprocessor responsible for redirecting ICs in order to reduce the amount of work in the DFG.

[0058] Microarchitecture (also “microprocessor architecture” ) is the way a given instruction set architecture is implemented in a particular processor.

[0059] Central processing unit (CPU) , also called a microprocessor or just a processor, is the electronic circuitry that executes instructions comprising a computer program.

[0060] Random access memory (RAM) is a form of computer memory that can be read and changed in any order, typically used to store working data and machine code.

[0061] Object-oriented programming (OOP) is a programming paradigm that treats data as an object that has both state and behavior.

[0062] Mutability refers to the ability of an object to be changed after it has been created; mutable objects can be changed in place, without creating a new object; and immutable objects, on the other hand, cannot be changed after they have been created.

[0063] An object, in OOP, is a self-contained entity that has state and behavior; the state of an object is represented by its data attributes, and the behavior of an object is represented by its methods.

[0064] Dataflow architecture is a computer architecture that directly contrasts with the traditional von Neumann architecture or control flow architecture. The latter executes instructions sequentially, while the former doesn’t have a program counter.

[0065] The main reason behind creating the dataflow way of computing was the idea that traditional von Neumann computers, which use a shared program counter and globally updatable memory, are inherently unsuitable for the exploitation of parallelism.

[0066] A dataflow architecture represents a program as a data flow graph (DFG) , where nodes are “operators” and directed edges between them are “channels” through which immutable data values travel. An operator is evaluated when data are present on all input channels. The completion of evaluation makes the resulting data available to the operators at the ends of output  channels. Thus, the order of operator evaluation is unpredictable.

[0067] To our best knowledge, one of the main issues of dataflow microprocessor is the data, which repeatedly moves back and forth between dataflow microprocessor and RAM, leading to large latency and efficiency losses. This negative effect is especially visible in programs dealing with massive amount of data that must be frequently transferred: neural networks, video and image processing, cryptography, databases, and so on. The latency may also affect the performance of object-oriented programs transformed into DFGs.

[0068] In FIG. 1, a C++ code that implements a pseudo-random number generator is shown. First, the generator, an instance of the Prng struct, is initialized via a constructor, which sets a local field last of the struct to a provided “seed” value. Then, the next () method is called twice-it calculates a pseudo-random number using the “middle-square method” (suggested by John von Neumann in 1946) . Important to notice that the next () method not only calculates a number, but also changes the value of the last field, which is used by later calls to the next () method.

[0069] It should be understood that in FIG. 1, the Prng struct (instances of which are objects in terms of C++) is mutable, since its last attribute changes its values after every call to the next () method. It is expected that this program after compilation and execution returns the exit code that is equal to 244, which is the lowest byte of 756 (the second random number) returned by the next () method.

[0070] In FIG. 2, the program of FIG. 1 represented in EO, an object-oriented dataflow programming language is shown. Here, the prng object has two attributes: 1) at line 19, the last attribute is a copy of a mutable memory object, which is similar to the mutable field in line 11, and 2) at lines 20–27, the next attribute is a sub-object representing the functionality of the pseudo-random number generating, similar to what the next () method at lines 4–9 is doing. The main object is the abstraction of the entire application; it consists of two attributes: 1) at line 29, the g attribute is a reference to the copy of the prng object with its only attribute initialized to the data 42, and 2) at lines 30–32, the “@” attribute is a reference to a copy of the seq object, which implements a sequential evaluation of a variadic number of objects. The implementation details of the next objects are not important within the scope of our technical solution, but they do work identically to C++ code at lines 4–9.

[0071] It should be understood that FIG. 2 shows a pseudo-random number generator implemented in EO, a dataflow programming language, such that it closely resembles the code written in C++ in FIG. 1. The Prng object contains a single mutable attribute named last, which is similar to the mutable class field last in the C++ code.

[0072] In FIG. 3, the program of FIG. 2 is rendered as a surging object di-graph (SODG) . The vertex denoted by Φ is the root object of the graph from which the evaluation starts. The edges between vertices denote relationships of ownership between objects. The labels on the edges are the names of the attributes. The mechanism of evaluation of the SODG is not explained  here, thus the graph is demonstrated merely in order to explain how objects are connected in the EO program through attributes. The details of the implementation of the last object are not visible on the graph, since the v5 object is a macro-operator.

[0073] In FIG. 3, the object of the highest level of abstraction is the Φ vertex, and other vertices are denoted as such: v1 represents the main object of the EO program, v2 represents the Prng, v3 represents the seq, v4 represents the memory, v5 represents the next, and v6 represents the int.

[0074] In FIG. 4, the program of FIG. 2 is rendered as a DFG. The vertices on the graph are operators that process data. The edges between the vertices are channels through which data travels. The edges are uni-directional, thus denoting the way in which the data travels. The operators without incoming edges are evaluated at the start of the program, since they have no demands for incoming data-there is only one operator of such kind on the graph: r1. All other operators are “fired” only when the data is available in all incoming edges. The r1 operator (the name is a short form of “read” ) , when being fired, reads the data (the integer 42) from RAM and pushes it to the nxt1 operator. The nxt1 operator turns 42 to 110, which is the next pseudo-random number, and pushes it to the w1 operator (the name is a short form of “write” ) . The w1 operator saves the data into RAM and then sends a control token to the r2 operator (control tokens are not different from regular data tokens, but for better understanding of the dataflow evaluation process they are named k, while data tokens are named d) . The r2 operator, when the k token arrives, reads the data from RAM and sends it to the nxt2 operator, the nxt2 operator turns 110 to 756, which is the next pseudo-random number, and sends it both to the seq operator and to the w2 operator. Thus, the memory object named last is represented by four operators in a DFG: r1, w1, r2, and w2.

[0075] FIG. 4 is a DFG for the project of FIG. 2, where the mutable object last is split into four operators in order to enable its stateful mechanics in connection with stateless next objects. The seq operator is stateless, since it does not send control-flow tokens but only accepts the data from the final operator in the chain of operators: nxt1 and nxt 2.

[0076] In FIG. 5, the evaluation workflow of the data flow graph of FIG. 4 is presented using data flow timeline (DFT) notation. In the DFT, time goes from left to right, while vertical bars denote ticks of a dataflow microprocessor. The text lines that stand right to a bar describe the evaluations performed by the microprocessor on a particular tick, most probably in chronological order from top to down. There are five ticks in FIG. 5, which are required in order to evaluate the graph depicted in FIG. 4: no matter how many cores a microprocessor has, five ticks is the minimum possible number.

[0077] It should be understood that, in FIG. 5, the names of the originating operators stay before the colon and the actions performed by them stay after the colon. An input channel of an operator is denoted by the name of the operator, the dot, and the name of the channel; for example, w1. d is the input channel d of the w1 operator.

[0078] Here, the term “tick” refers to a full cycle of advancing the entire DFG to its next state: ICs are generated, processed,  and then distributed for all operators that have sufficient input data. This definition differs from the concept of a “tick” in a control-flow microprocessor.

[0079] From FIG. 4, it can be seen that multiple operators perform repetitive write and read operations on RAM, which leads to significant latency and efficiency loss, thereby increasing the workload in the DFG. This negative effect is especially visible in programs dealing with massive amount of data that must be frequently transferred.

[0080] To solve the problem above, embodiments of the present application provide a method and device, which may reduce the amount of work in the DFG.

[0081] FIG. 6 is a schematic diagram of a method of calculation based on a data flow graph (DFG) . The method may be performed by a dataflow microprocessor for calculation based on a DFG, or by a module or a unit in the dataflow microprocessor for calculation based on the DFG. The method specifically includes the following steps.

[0082] An example, the dataflow microprocessor includes a distribution advisor (DA) , the method in the FIG. 6 is applied to the DA.

[0083] Step 610: obtain a first DFG, where the first DFG comprises a number of operators and data transmitted between the number of operators.

[0084] In the implementation example of this application, the first DFG runs on the dataflow microprocessor.

[0085] As an example, the dataflow processor includes OUs, and the first DFG is the software running in the Ous. Specifically, the operators in the first DFG is software, which runs in the Ous.

[0086] Step 620: optimize the first DFG to a second DFG based on the a connection relationship of the operators and / or the data transmitted between the operators in the first DFG.

[0087] In the implementation example of this application, the second DFG runs on the dataflow microprocessor.

[0088] As an example, the second DFG is the software running in the Ous. Specifically, the operators in the second DFG is software, which runs in the Ous.

[0089] Step 630: execute the second DFG on the dataflow microprocessor.

[0090] According to the method above, based on the connection relationship of the operators in the first DFG and / or the data transmitted between the operators, the first DFG running in the dataflow microprocessor is optimized to obtain the second DFG, which is then run in the dataflow microprocessor. Due to the optimization of the second DFG compared to the first DFG, it can improve the execution efficiency of the dataflow microprocessor and also reduce the latency of the dataflow microprocessor.

[0091] In one possible implementation, compared to the first DFG, the second DFG reduces the number of operators, thereby improving the execution efficiency of the dataflow microprocessor and also reduce the latency of the dataflow microprocessor.

[0092] As an example, compared to the first DFG, the second DFG reduces unnecessary round-trips between the operators in the first DFG and RAM, thereby avoiding unnecessary interaction between the dataflow microprocessor and the RAM, and improving the execution efficiency of the dataflow microprocessor.

[0093] In a possible design, where the first DFG includes a first operator, a second operator, a third operator and a fourth operator, where the first operator outputs first data and sends the first data to the third operator, the third operator writes the first data into the RAM, and the fourth operator retrieves the first data from the RAM and sends the first data to the second operator, and the second DFG includes the first operator and the second operator, where the first operator in the second DFG outputs the first data and sends the first data to the second operator in the second DFG directly.

[0094] In another possible design, where the first DFG also includes multiple fifth operators, where the multiple fifth operators respectively obtain second data from the second operator and send the second data to the RAM, and the second DFG also includes one of the fifth operators, where the one fifth operator in the second DFG obtains the second data from the second operator in the second DFG and sends the second data to the RAM.

[0095] In another possible design, optimize the first DFG based on the data transmitted in each operating unit of the first DFG to obtain the second DFG

[0096] As an example, where the first DFG also includes a sixth operator, the first operator in the first DFG also sends the first data to the sixth operator in the first DFG, the sixth operator in the first DFG obtains third data based on the first data, and sends the third data to the third operator in the first DFG, the third operator in the first DFG also writes the third data into the RAM, the fourth operator in the first DFG also retrieves the third data from the RAM and sends the third data to the second operator in the first DFG, and the first operator in the second DFG also obtains the third data based on the first data, and sends the third data to the second operator in the second DFG.

[0097] As an example, the sixth operator in the first DFG is a decrementor.

[0098] In the above technical solution, by leveraging intrinsic knowledge of operator semantics such as memory writers and readers, dataflow is optimized in microprocessors. It replaces a single RAM round-trip with a direct data delivery to the recipient operator, subsequently establishes synthetic dataflow edges in their place, enhances data routing efficiency by detecting and eliminating unnecessary round-trips to RAM, thereby reducing the number of ticks in the dataflow microprocessor. Our solution thus represents a substantial leap forward in the pursuit of heightened dataflow microprocessor efficiency and performance.

[0099] The best way to demonstrate our solution is by using an example in which the DFG in FIG. 4 may be optimized as shown in FIG. 7, where the functionality is preserved but the nxt1 operator sends data directly to the nxt2 operator instead of  to the w1 operator.

[0100] In FIG. 7, redundant round-trips are eliminated by creating a new synthetic edge between the nxt1 and nxt2 operators. The data will not be sent through the edge between the nxt1 and w1 operators, and that’s why the edges are not visible in the DFG anymore.

[0101] This optimization leads to a shorter evaluation timeline, as shown in FIG. 8. The operators w1 and r2 do not receive data at all and because of that writing and reading operations are not made with RAM.

[0102] In FIG. 8, the DFT of evaluation of the DFG in FIG. 6 is shorter than the timeline in FIG. 5, because the data transfers directly from the nxt1 operator to the nxt2 operator without a round-trip to RAM.

[0103] In one possible implementation, FIG. 9 shows an architecture of a dataflow microprocessor, which includes: a distribution advisor (DA) , a distribution network, a set of operators in a DFG, an arbitration network, and a set of operation units. The DA stands ahead of the distribution network and makes additional distribution decisions about possible synthetic edges between operators.

[0104] It should be understood that, distribution network、arbitration network and operation units are all hardware. Operator contains the information that helps creating instruction cells. Arbitration Network uses this information in order to create instruction cells. Arbitration Network reads the DFG, which is uploaded to the microprocessor’s memory by a programmer. DFG is a set of operators. The Arbitration Network takes the next operator that is ready to be evaluated, creates a new instruction cell and sends it to the next available operation unit (also known as ALU) . The operation unit performs calculations and adds more data to the instruction cell. Then, the instruction cell goes to the DA, where the decision is made whether to optimize it or not. Then, the DA pushes the instruction cell to the distribution network, which decides were to put the data that were generated by the ALU. When the decision is made, the data is placed into new instruction cells and they start to travel through the same cycle.

[0105] It should also be understood that, Operator is a software component, like a command that is uploaded to the microprocessor, whitch runs on the operation unit. Instruction cell is a piece of data (20-50 bytes) that arbitration network creates, sends to operation units, and then sends to distribution network (DA) .

[0106] To implement the optimization from the DFG of FIG. 4 to the DFG of FIG. 7, in one possible implementation, in FIG. 9, we propose integrating an additional component (the DA) into the dataflow microprocessor. This component would be responsible for identifying unnecessary round-trips to RAM and then creating shortcuts through synthetic dataflow edges.

[0107] In the specific scenario of FIG. 7, the DA observes that the data intends to travel from the nxt1 operator to the w1 operator and then will return to the nxt2 operator via RAM, and subsequently pass through the r2 operator. The semantics of  both the w1 and r2 operators are known to the DA: they are memory writers and readers, respectively. With this knowledge, and also understanding that there are no other readers from this portion of RAM, the DA can decide that the data can be directly sent to nxt2, thus forming a synthetic edge from nxt1 to nxt2.

[0108] It should be noted that, it may be tempting to send the data directly from the nxt1 operator to the seq operator, but the DA will refrain from doing so as it doesn’t understand the semantics of the nxt2 operator. The nxt2 operator is a macro-operator with an embedded control-flow microprogram. Sending the data directly from the nxt1 operator to the seq operator would be erroneous, as such an optimization would bypass the calculation of the second pseudo-random number. Consequently, the result of the program evaluation would be 110 (mistake) instead of 756 (correct result) .

[0109] In FIG. 9, the applicability of the DA in a dataflow microprocessor may differ:

[0110] 1. The DA may implement different algorithms, rather than only focused on reducing the number of round-trips to RAM;

[0111] 2. Instead of being a separate component ahead of the Distribution Network, the DA may be part of it, follow it, or even replace it.

[0112] 3. The DA may not only redirect the data, but also modify it in order to reduce the amount of calculations made by the OUs, as FIG. 14 demonstrates.

[0113] 4. The DA may accumulate information about data distribution into ICs and then use it to make more effective decisions for data redirection.

[0114] 5. The DA may play a similar role in a multi-core or cluster architecture, redirecting data between DFGs, not only inside one DFG.

[0115] In one possible implementation, FIG. 10 shows an activity diagram of a workflow performed by a DA on each arrival of an IC: the decision is made about whether the redirection is possible and then new ICs are produced, replacing the arrived one.

[0116] In one possible implementation, FIG. 11 shows another architecture of a dataflow microprocessor. The DA in FIG. 11 may employ additional OUs for arithmetic or other calculations that are performed before ICs arrive at the DN (they are denoted as AOU on the diagram) . The computation power of AOUs depends on the complexity of calculations to be performed by the microprocessor and may even be larger than the computation power of OUs. The central part of the diagram is a simplification of what FIG. 9 illustrates.

[0117] The following will list some implementation details.

[0118] While the implementation of the DA might differ depending on the types of redirecting decisions it makes, there are  several mechanisms that could optimize redundant round-trips to RAM.

[0119] If the DFG is formulated as a predicate e (a, v1, v2) that holds when there is a directed edge labeled a departing from v1 vertex and arriving at v2 vertex, then the optimization decision of FIG. 6 can be expressed as the rewrite rule of Eq. (1) . If the premise of the rule holds true, the DFG can be modified such that the conclusion of the rule also becomes true.

[0120] The predicate m (v, a) holds if vertex v accesses the part of RAM located at address a. Both predicates e and m are relatively easy to implement at the hardware level, as the m predicate is not expected to be total. It may only hold when the semantics of the first argument (the vertex) are clear and fall into one of two categories: a reader from RAM or a writer to RAM. If the semantics are unknown, the predicate might not hold, even mistakenly. FIG. 12 visually demonstrates the effect of Eq. (1) .

[0121] The results of the evaluation of both e and m predicates can be cached by the CPU, as they are constants: they won’t change until the end of the program’s execution. Moreover, they can be evaluated at the beginning of the program’s execution, reducing the time required for the DA to make data redirection decisions during runtime.

[0122] In FIG. 12, the optimization of the rewriting rule of Eq. (1) is demonstrated visually. The DFG at (A) has only two edges, while the DFG (B) gets a new synthetic edge departing from v1 and arriving at v2, provided that  m (vw, a) ∧ m (vr, a) , where vw is the “writer” and vr is the “reader” of the same address in RAM.

[0123] In one possible implementation, we implemented a simulator for a dataflow machine using the Ruby programming language to validate the mechanics of the DA. The source code is hosted in a GitHub repository. The DFT timelines in FIG. 5 and FIG. 8 were rendered using this simulator. Furthermore, FIG. 13 showcases the timeline the simulator produces when the functionality of the DA is enabled. The line beginning with the “DA: ” prefix in the second tick is generated by the DA module. It redirected data intended for the w1 operator to the nxt2 operator instead. This decision was made by the DA module based on the mechanics of Eq. (1) .

[0124] In FIG. 13, the DFT of evaluation of the DFG in FIG. 4 on the simulator with an enabled module that reproduces the functionality of the DA, is written in Ruby programming language.

[0125] A potential subject for future research would be to develop a translator that converts C++ programs (or those from any other object-oriented language) into a DFG format. Following this, the mechanics of its evaluation can then be verified using our simulator.

[0126] The following will explain how much information the DA needs to know about the DFG.

[0127] The DA can gain insights into operator semantics either at compile time or runtime. During the compile time, a compiler understands the semantics of each operator in the DFG. It then supplies this knowledge as supplementary metadata about the compiled program. At the runtime, the DA can analyze the DFG either preemptively before the program runs or as needed. Given that the DFG size in macro-dataflow microprocessors remains relatively small, scanning the entire DFG is time-efficient. Importantly, the DA doesn’t need to grasp the complete semantics of each operator. It only requires knowledge of whether the operator has read / written data from the RAM and the unique location of the block inside RAM it interacts with (the absolute value of the address is not required) .

[0128] The following will explain why the DFG can’t be optimized in the compile time.

[0129] Some inefficiencies within DFGs can be addressed statically at the compile time, even before the DFG is dispatched to the microprocessor. However, certain dynamic details crucial for optimization decisions might not be accessible to the compiler, including a) the frequency with which certain operators are utilized, b) the magnitude of data being channeled through edges, and c) the completion status of ICs.

[0130] The following will explain the differences between the DA and JIT compilers.

[0131] The DA’s role can somewhat be parallel that of the JIT compiler-acomponent of the JavaTM Virtual Machine that bolsters Java application performance by translating bytecodes to native machine code in real-time. Although such a transition to native machine code can technically be executed by the compiler for the entire application, it’s postponed until runtime for various reasons. Interestingly, these reasons echo the motives behind delegating DFG optimization to the DA.

[0132] The following will explain how data size may affect the decisions of the DA

[0133] The data transfer capacity between operators in a DFG is bound by the physical architecture of the CPU. It’s prudent to surmise that in contemporary CPUs, DFG edges may not be equipped for megabyte-scale data transfers. Bearing this constraint, the DA must calibrate its redirection choices: sidestepping redirection when data sizes surpass this threshold.

[0134] The following will explain how much computation power the DA can have.

[0135] FIG. 14 demonstrates how the DA can do mathematical decrement of an integer in order to save a CPU tick. The DA may do more complex operations, including multiplication, division, bitwise shifting, and other traditional data manipulations available in control-flow CPUs. The DA may by itself become a co-processor, helping the dataflow microprocessor optimize the evaluation flow and minimize the number of required ticks. Also, the DA may employ supplementary OUs, delegating to them a part of workload, as FIG. 11 illustrates.

[0136] In FIG. 14, if the semantic of the v2 operator is known and it is a “decrementor” of the data arriving, which is a typical pattern for loops and recursion, the data may directly be sent to the arriving operator, thus reducing the number of CPU  ticks by one. The edge from the v1 to v2 operator may be removed in order to avoid data redundancy.

[0137] The following will explain the smallest DFG mode that can be optimized.

[0138] The optimizations made by the DA make sense only when three or more operators are involved, for example, FIG. 14 illustrates: the “originating” operator that fills up the IC, the “receiving” operator, and the “alternative” operator, which takes place of the receiving operator. FIG. 15 illustrates a segment of the DFG, where the data token from operator v1 travels to two operators w1 and w2, which both are writers to the same place in RAM. It is obvious that double writing into the same part of the RAM may be simplified to a single writing, thus skipping the travel of data to operator w2 (for example) .

[0139] In FIG. 15, the operator v1 in the DFG fragment (A) sends the same data to two writers w1 and w2, which are connected to the same place in RAM. The fragment (B) is modified by the DA such that the data is sent only to one writer w1, which decreases the number of ticks in the microprocessor.

[0140] The following two-fold positive effect may be achieved due to the use of the DA in a dataflow microprocessor architecture, for some DFGs:

[0141] 1. The number of round-trips to RAM can be reduced, and

[0142] 2. The number of CPU cycles can be decreased.

[0143] The ultimate result of this two-fold effect is the reduction in the time required for the evaluation of the entire DFG or some of its sub-graphs.

[0144] The primary objective of our invention is to design a dataflow microprocessor for general-purpose programming languages, such as C++ or Java. There have been earlier attempts to create such microprocessors specifically engineered to execute object-oriented programs. However, to the best of our knowledge, none of these approaches utilized the principles of dataflow architecture. We anticipate that a dataflow microprocessor, equipped with our invention and executing C++ programs (translated to EO beforehand) , could demonstrate significantly higher performance than control flow architectures running the same C++ programs.

[0145] Our invention belongs to the area of internal design of a microprocessor architecture ( “G06F7” IPC category) . Due to the microscopic nature of microprocessors, it is almost impossible to decompose a solution of a competitor and prove that their dataflow architecture contains the DA. However, there are a few possible implicit indicators that may help:

[0146] 1. If a program with certain amount of stateful operators makes fewer round-trips to RAM than it theoretically should make, this may be an obvious indicator of the usage of the DA in the microprocessor. The number of round-trips may be calculated by scanning a memory bus. However, CPU cache may interfere by reducing the number of round-trips to RAM.

[0147] 2. If a program with certain number of operators makes fewer ticks than it theoretically should make, this may be an  indicator of the usage of the DA.

[0148] 3. If the binary workload output from a compiler contains supplementary meta-data about the semantics of DFG operators, specifically detailing memory readers / writers and their interactions with RAM, this could signal the usage of the DA.

[0149] It may be challenging, but possible, to determine whether a competitor’s dataflow microprocessor architecture incorporates the DA using publicly available product documentation such as user manuals, white papers, and videos. Indicators could include:

[0150] 1. If they guarantee that object-oriented programs with stateful (mutable) objects may run faster than expected due to internal optimizations of the processors, it’s highly likely that these optimizations are achieved through the usage of the DA.

[0151] 2. If they promise specific DFG optimizations to be made in runtime by the processor, which aren’t provided by the compiler, it’s probable that such optimizations are carried out by the DA located ahead of the Distribution Network.

[0152] 3. If they assure a runtime reduction of inefficiencies caused by read-write memory operations, they are likely referring to the presence of the DA.

[0153] FIG. 16 is a schematic block diagram of a dataflow microprocessor 1600 according to an embodiment of this application. As shown in FIG. 16, the dataflow microprocessor 1600 includes: an obtaining unit 1601, an optimizing unit1602, and an executing unit 1603.

[0154] As an example, the dataflow microprocessor 1600 is configured for calculation based on a data flow graph (DFG) , the obtaining unit 1601 is configured to obtain, afirst DFG, wherein the first DFG comprises a number of operators and data transmitted between the number of operators, the first DFG runs on the dataflow microprocessor; the optimizing unit1602 is configuredto optimize, according to a connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to a second DFG, wherein the second DFG runs on the dataflow microprocesso; and the executing unit 1603 is configured to execute the second DFG.

[0155] In some embodiments, the optimizing unit is specifically configured to optimize, by reducing the number of round-trips between the operators and a random access memory (RAM) in the first DFG, the first DFG to the second DFG.

[0156] In some embodiments, where the first DFG comprises a first operator, a second operator, a third operator and a fourth operator, where the first operator outputs first data and sends the first data to the third operator, the third operator writes the first data into the RAM, and the fourth operator retrieves the first data from the RAM and sends the first data to the second operator, and the second DFG comprises the first operator and the second operator, where the first operator in the second DFG outputs the first data and sends the first data to the second operator in the second DFG directly.

[0157] In some embodiments, where the first DFG also comprises multiple fifth operators, where the multiple fifth operators  respectively obtain second data from the second operator and send the second data to the RAM, and the second DFG also comprises one of the fifth operators, where the one fifth operator in the second DFG obtains the second data from the second operator in the second DFG and sends the second data to the RAM.

[0158] In some embodiments, where the optimizing unit, is specifically configured to optimize, by calculating the data transmitted between the operators in the first DFG, the first DFG to the second DFG.

[0159] In some embodiments, where the first DFG also comprises a sixth operator, the first operator in the first DFG also sends the first data to the sixth operator in the first DFG, the sixth operator in the first DFG obtains third data based on the first data, and sends the third data to the third operator in the first DFG, the third operator in the first DFG also writes the third data into the RAM, the fourth operator in the first DFG also retrieves the third data from the RAM and sends the third data to the second operator in the first DFG, and the first operator in the second DFG also obtains the third data based on the first data, and sends the third data to the second operator in the second DFG.

[0160] In some embodiments, the sixth operator is a decrementor.

[0161] In some embodiments, where the dataflow microprocessor 1600 further includes: a understanding unit, whitch is configured to understand semantics of the number of operators in the first DFG.

[0162] As shown in FIG. 17, a computing device 1700 may include a transceiver 1701, a processor 1702, and a memory 1703. The memory 1703 may be configured to store code, instructions, and the like executed by the processor 1702.

[0163] It should be understood that processor 1702 in computing device 1700 can correspond to the dataflow microprocessor 1600.

[0164] It should be understood that the processor 1702 may be an integrated circuit chip and has a signal processing capability. In an implementation process, steps of the foregoing method embodiments may be completed by using a hardware integrated logic circuit in the processor, or by using instructions in a form of software. The processor may be a general-purpose processor, a central processing unit (CPU) , a graphics processing unit (GPU) , a neural processing unit (NPU) , a system on chip (SoC) or another programmable logic device, a discrete gate or transistor logic device, or a discrete hardware component. The processor may implement or perform the methods, the steps, and the logical block diagrams that are disclosed in the embodiments of the present application. The general-purpose processor may be a microprocessor, or the processor may be any conventional processor or the like. The steps of the methods disclosed with reference to the embodiments of the present application may be directly performed and completed by a hardware decoding processor, or may be performed and completed by using a combination of hardware in the decoding processor and a software module. The software module may be located in a mature storage medium in the art, such as a random access memory, a flash memory, a read-only memory, a programmable read-only  memory, an electrically erasable programmable memory, or a register. The storage medium is located in the memory, and the processor reads information in the memory and completes the steps of the foregoing methods in combination with hardware in the processor.

[0165] It may be understood that the memory 1703 in the embodiments of the present application may be a volatile memory or a non-volatile memory, or may include both a volatile memory and a non-volatile memory. The non-volatile memory may be a read-only memory (Read-Only Memory, ROM) , a programmable read-only memory (Programmable ROM, PROM) , an erasable programmable read-only memory (Erasable PROM, EPROM) , an electrically erasable programmable read-only memory (Electrically EPROM, EEPROM) , or a flash memory. The volatile memory may be a random access memory (Random Access Memory, RAM) and is used as an external cache. By way of example rather than limitation, many forms of RAMs may be used, and are, for example, a static random access memory (Static RAM, SRAM) , a dynamic random access memory (Dynamic RAM, DRAM) , a synchronous dynamic random access memory (Synchronous DRAM, SDRAM) , a double data rate synchronous dynamic random access memory (Double Data Rate SDRAM, DDR SDRAM) , an enhanced synchronous dynamic random access memory (Enhanced SDRAM, ESDRAM) , a synchronous link dynamic random access memory (Synchronous link DRAM, SLDRAM) , and a direct rambus random access memory (Direct Rambus RAM, DR RAM) .

[0166] It should be noted that the memory in the systems and the methods described in this specification includes but is not limited to these memories and a memory of any other appropriate type.

[0167] An embodiment of this application further provides a system chip, where the system chip includes an input / output interface, at least one processor, at least one memory, and a bus. The at least one memory is configured to store instructions, and the at least one processor is configured to invoke the instructions of the at least one memory to perform operations in the methods in the foregoing embodiments.

[0168] An embodiment of this application further provides a computer storage medium, where the computer storage medium may store a program instruction for performing any of the foregoing methods.

[0169] Optionally, the storage medium may be specifically the memory 1703.

[0170] A person of ordinary skill in the art may be aware that, in combination with the examples described in the embodiments disclosed in this specification, units and algorithm steps can be implemented by electronic hardware or a combination of computer software and electronic hardware. Whether the functions are performed by hardware or software depends on particular applications and design constraints of the technical solutions. A person skilled in the art may use different methods to implement the described functions for each particular application, but it should not be considered that the implementation goes beyond the scope of this application.

[0171] It may be clearly understood by a person skilled in the art that, for the purpose of convenient and brief description, for a detailed working process of the foregoing system, apparatus, and unit, refer to a corresponding process in the foregoing method embodiment. Details are not described herein again.

[0172] In the several embodiments provided in this application, it should be understood that the disclosed system, apparatus, and method may be implemented in other manners. For example, the described apparatus embodiment is merely an example. For example, the unit division is merely logical function division and may be other division in actual implementation. For example, a plurality of units or components may be combined or integrated into another system, or some features may be ignored or not performed. In addition, the displayed or discussed mutual couplings or direct couplings or communication connections may be implemented through some interfaces. The indirect couplings or communication connections between the apparatuses or units may be implemented in electronic, mechanical, or other forms.

[0173] The units described as separate parts may be or may not be physically separate, and parts displayed as units may be or may not be physical units, may be located in one position, or may be distributed on a plurality of network units. Some or all of the units may be selected based on actual requirements to achieve the objectives of the solutions of the embodiments.

[0174] In addition, functional units in the embodiments of this application may be integrated into one processing unit, or each of the units may exist alone physically, or two or more units are integrated into one unit.

[0175] When the functions are implemented in a form of a software functional unit and sold or used as an independent product, the functions may be stored in a computer readable storage medium. Based on such an understanding, the technical solutions in this application essentially, or the part contributing to the prior art, or some of the technical solutions may be implemented in a form of a software product. The computer software product is stored in a storage medium, and includes several instructions for instructing a computer device (which may be a personal computer, a server, a network device, or the like) to perform all or some of the steps of the methods described in the embodiments of this application. The foregoing storage medium includes: any medium that can store program code, such as a USB flash drive, a removable hard disk, a read-only memory (Read-Only Memory, ROM) , a random access memory (Random Access Memory, RAM) , a magnetic disk, or an optical disc.

[0176] The foregoing descriptions are merely specific implementations of this application, but are not intended to limit the protection scope of this application. Any variation or replacement readily figured out by a person skilled in the art within the technical scope disclosed in this application shall fall within the protection scope of this application. Therefore, the protection scope of this application shall be subject to the protection scope of the claims.

Claims

1.A method of calculation based on a data flow graph (DFG) , the method is applied to a dataflow microprocessor, the method comprising:obtaining a first DFG, wherein the first DFG comprises a number of operators and data transmitted between the number of operators, the first DFG runs on the dataflow microprocessor;optimizing, according to a connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to a second DFG, wherein the second DFG runs on the dataflow microprocesso; andexecuting the second DFG.2.The method according to claim 1, wherein optimizing, according to the connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to the second DFG comprises:optimizing, by reducing the number of round-trips between the operators and a random access memory (RAM) in the first DFG, the first DFG to the second DFG.3.The method according to claim2, wherein the first DFG comprises a first operator, a second operator, a third operator and a fourth operator, wherein the first operator outputs first data and sends the first data to the third operator, the third operator writes the first data into the RAM, and the fourth operator retrieves the first data from the RAM and sends the first data to the second operator, and the second DFG comprises the first operator and the second operator, wherein the first operator in the second DFG outputs the first data and sends the first data to the second operator in the second DFG directly.4.The method according to claim 3, wherein the first DFG also comprises multiple fifth operators, wherein the multiple fifth operators respectively obtain second data from the second operator and send the second data to the RAM, and the second DFG also comprises one of the fifth operators, wherein the one fifth operator in the second DFG obtains the second data from the second operator in the second DFG and sends the second data to the RAM.5.The method according to any one of claims 1-4, wherein optimizing, according to the connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to the second DFG comprises:optimizing, by calculating the data transmitted between the operators in the first DFG, the first DFG to the second DFG.6.The method according to claim 5, wherein the first DFG also comprises a sixth operator, the first operator in the first DFG also sends the first data to the sixth operator in the first DFG, the sixth operator in the first DFG obtains third data based  on the first data, and sends the third data to the third operator in the first DFG, the third operator in the first DFG also writes the third data into the RAM, the fourth operator in the first DFG also retrieves the third data from the RAM and sends the third data to the second operator in the first DFG, and the first operator in the second DFG also obtains the third data based on the first data, and sends the third data to the second operator in the second DFG.7.The method according to claim 6, wherein the sixth operator in the first DFG is a decrementor.8.The method according to any one of claims 1-7, wherein the method further comprises:understanding semantics of the number of operators in the first DFG.9.The method according to any one of claims 1-8, wherein the method is applied to a distribution advisor (DA) in the dataflow microprocessor.10.A dataflow microprocessor for calculation based on a data flow graph (DFG) , the dataflow microprocessor comprising:an obtaining unit, configured to obtain, afirst DFG, wherein the first DFG comprises a number of operators and data transmitted between the number of operators, the first DFG runs on the dataflow microprocessor;an optimizing unit, configured to optimize, according to a connection relationship of the operators and / or the data transmitted between the operators in the first DFG, the first DFG to a second DFG, wherein the second DFG runs on the dataflow microprocesso; andan executing unit, configured to execute the second DFG.11.The dataflow microprocessor according to claim 10, whereinthe optimizing unit, is specifically configured to optimize, by reducing the number of round-trips between the operators and a random access memory (RAM) in the first DFG, the first DFG to the second DFG.12.The dataflow microprocessor according to claim 10 or 11, wherein the first DFG comprises a first operator, a second operator, a third operator and a fourth operator, wherein the first operator outputs first data and sends the first data to the third operator, the third operator writes the first data into the RAM, and the fourth operator retrieves the first data from the RAM and sends the first data to the second operator, and the second DFG comprises the first operator and the second operator, wherein the first operator in the second DFG outputs the first data and sends the first data to the second operator in the second DFG directly.13.The dataflow microprocessor according to claim 12, wherein the first DFG also comprises multiple fifth operators, wherein the multiple fifth operators respectively obtain second data from the second operator and send the second data to the RAM, and the second DFG also comprises one of the fifth operators, wherein the one fifth operator in the second DFG obtains the second data from the second operator in the second DFG and sends the second data to the RAM.14.The dataflow microprocessor according to any one of claims 10-13, whereinthe optimizing unit, is specifically configured to optimize, by calculating the data transmitted between the operators in the first DFG, the first DFG to the second DFG.15.The dataflow microprocessor according to claim 14, wherein the first DFG also comprises a sixth operator, the first operator in the first DFG also sends the first data to the sixth operator in the first DFG, the sixth operator in the first DFG obtains third data based on the first data, and sends the third data to the third operator in the first DFG, the third operator in the first DFG also writes the third data into the RAM, the fourth operator in the first DFG also retrieves the third data from the RAM and sends the third data to the second operator in the first DFG, and the first operator in the second DFG also obtains the third data based on the first data, and sends the third data to the second operator in the second DFG.16.The dataflow microprocessor according to claim 15, wherein the sixth operator in the first DFG is a decrementor.17.The dataflow microprocessor according to any one of claims 10-16, wherein the dataflow microprocessor further comprises:a understanding unit, configured to understand semantics of the number of operators in the first DFG.18.A computer readable storage medium storing instructions that, when run on a server, enable the server to perform the method according to any one of claims 1 to 9.19.A computing device cluster, comprising at least one computing device, wherein the computing device comprises a processor and a memory coupled with the processor, wherein the memory is configured to store a computer program, and the processor is configured to invoke and run the computer program stored in the memory, so that the computing device executes the method according to any one of claims 1 to 9.20.A computer program product, wherein when the computer program product is run on a server, the server is enabled to perform the method according to any one of claims 1 to 9.

Images