Patent Grant
11138019
Examples of the present disclosure generally relate to electronic circuit design and, in particular, to routing in a compilation flow for a heterogeneous multi-core architecture.
A processor, a system on a chip (SoC), and an application specific integrated circuit (ASIC) can include multiple cores for performing compute operations such as processing digital signals, performing cryptography, executing software applications, rendering graphics, and the like. While there are many multi-core architectures, none of the compilers for these architectures directly address heterogeneous architectures, in particular multi-core processors coupled to reconfigurable/programmable logic (e.g., a field programmable gate array (FPGA) fabric). In addition, existing compilers do not solve the mapping of compute kernels to processor cores and data structures to memory banks, and the routing of stream data and direct memory access (DMA) data between processor cores, and between processor cores and programmable logic.
Techniques related to a compilation flow for a heterogeneous multi-core architecture are described. In an example, a method of implementing an application for a system-on-chip (SOC) having a data processing engine (DPE) array including: determining a graph representation of the application, the graph representation including nodes representing kernels of the application and edges representing communication between the kernels; mapping, based on the graph, the kernels onto DPEs of the DPE array and data structures of the kernels onto memory in the DPE array; building a routing graph of all possible routing choices in the DPE array for communicate channels between DPEs and circuitry of the application configured in programmable logic of the SOC; adding constraints to the routing graph based on an architecture of the DPE array; routing communication channels between DPEs and circuitry of the application configured in programmable logic of the SOC based on the routing graph; and generating implementation data for programming the SOC to implement the application based on results of the mapping and the routing.
In another example, a non-transitory computer readable medium having stored thereon instructions that when executed by a processor cause the process to perform a method of implementing an application for a system-on-chip (SOC) having a data processing engine (DPE) array, including: determining a graph representation of the application, the graph representation including nodes representing kernels of the application and edges representing communication between the kernels; mapping, based on the graph, the kernels onto DPEs of the DPE array and data structures of the kernels onto memory in the DPE array; building a routing graph of all possible routing choices in the DPE array for communicate channels between DPEs and circuitry of the application configured in programmable logic of the SOC; adding constraints to the routing graph based on an architecture of the DPE array; routing communication channels between DPEs and circuitry of the application configured in programmable logic of the SOC based on the routing graph; and generating implementation data for programming the SOC to implement the application based on results of the mapping and the routing.
In another example, a computer system, including: a memory configured to store program code; and a processor configured to execute the program code to implement an application for a system-on-chip (SOC) having a data processing engine (DPE) array by: determining a graph representation of the application, the graph representation including nodes representing kernels of the application and edges representing communication between the kernels; mapping, based on the graph, the kernels onto DPEs of the DPE array and data structures of the kernels onto memory in the DPE array; building a routing graph of all possible routing choices in the DPE array for communicate channels between DPEs and circuitry of the application configured in programmable logic of the SOC; adding constraints to the routing graph based on an architecture of the DPE array; routing communication channels between DPEs and circuitry of the application configured in programmable logic of the SOC based on the routing graph; and generating implementation data for programming the SOC to implement the application based on results of the mapping and the routing.
These and other aspects may be understood with reference to the following detailed description.
So that the manner in which the above recited features can be understood in detail, a more particular description, briefly summarized above, may be had by reference to example implementations, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only typical example implementations and are therefore not to be considered limiting of its scope.
To facilitate understanding, identical reference numerals have been used, where possible, to designate identical elements that are common to the figures. It is contemplated that elements of one example may be beneficially incorporated in other examples.
Various features are described hereinafter with reference to the figures. It should be noted that the figures may or may not be drawn to scale and that the elements of similar structures or functions are represented by like reference numerals throughout the figures. It should be noted that the figures are only intended to facilitate the description of the features. They are not intended as an exhaustive description of the claimed invention or as a limitation on the scope of the claimed invention. In addition, an illustrated example need not have all the aspects or advantages shown. An aspect or an advantage described in conjunction with a particular example is not necessarily limited to that example and can be practiced in any other examples even if not so illustrated or if not so explicitly described.
Techniques described herein provide a process for taking a graph-based programmatic description of an application for a multi-core architecture of a system-on-chip (SOC) and compiling the application to the multi-core architecture to produce execution binaries for each core and configuration code for programmable components. The compilation steps include transforming the input graph description to an internal representation, performing code analysis and optimization, identifying which computation kernels should be grouped together (e.g., clustering), mapping these groups to specific data processing engines (e.g., cores) and the data structures used by the kernels to local memory. The compilation steps further include routing stream and direct memory access (DMA) data between data processing engines and to and from programmable logic via stream switches. The compilation steps further include generating wrapper code to orchestrate the execution of each data processing engine, generating the configuration code for the DMAs and stream switches, and generating a program for execution by a processing system to control the application. These and further aspects are discussed below with respect to the drawings.
In one embodiment, the DPEs 110 are identical. That is, each of the DPEs 110 (also referred to as tiles or blocks) may have the same hardware components or circuitry. Further, the examples herein are not limited to DPEs 110. Instead, the device 100 can include an array of any kind of processing elements or data processing engines. Moreover, the DPEs 110 could be cryptographic engines or other specialized hardware for performing one or more specialized tasks. As such, the DPEs 110 can be referred to generally as data processing engines.
In
In one embodiment, the DPEs 110 are formed from non-programmable logic—i.e., are hardened. One advantage of doing so is that the DPEs 110 may take up less space in the device 100 relative to using programmable logic to form the hardware elements in the DPEs 110. That is, using hardened or non-programmable logic circuitry to form the hardware elements in the DPEs 110 such as program memories, an instruction fetch/decode unit, fixed-point vector units, floating-point vector units, arithmetic logic units (ALUs), multiply accumulators (MAC), and the like can significantly reduce the footprint of the array 105 in the device 100. Although the DPEs 110 may be hardened, this does not mean the DPEs 110 are not programmable. That is, the DPEs 110 can be configured when the device 100 is powered on or rebooted to perform different functions or tasks.
The DPE array 105 also includes an SoC interface block 115 that serves as a communication interface between the DPEs 110 and other hardware components in the device 100. In this example, the device 100 includes a network on chip (NoC) 120 that is communicatively coupled to the SoC interface block 115. Although not shown, the NoC 120 may extend throughout the device 100 to permit the various components in the device 100 to communicate with each other. For example, in a physical implementation, the DPE array 105 may be disposed in an upper right portion of the integrated circuit forming the device 100. However, using the NoC 120, the array 105 can nonetheless communicate with various subsystems, for example, programmable logic (PL) 120, a processor subsystem (PS) 130 or input/output (I/O) 135 which may disposed at different locations throughout the device 100.
In addition to providing an interface between the DPEs 110 and the NoC 120, the SoC interface block 115 may also provide a connection directly to a communication fabric in the PL 122. In one embodiment, the SoC interface block 115 includes separate hardware components for communicatively coupling the DPEs 110 to the NoC 120 and to the PL 122 that is disposed near the array 105 in the device 100.
Although
The core 202 includes one or more compute units for processing data according to instruction(s) stored in the PM 206. In an example, the core 202 includes a very-long instruction word (VLIW) processor, a single instruction, multiple data (SIMD) or vector processor, or a VLIW SIMD/vector processor. In an example, the PM 206 is private to the core 202 (e.g., the PM 206 stores instruction(s) only for use by the core 202 in the DPE 200). In an example, the PM 206 comprises a single-ported random access memory (RAM). The PM 206 can be coupled to the MM interconnect 212 for configuration and loading of instructions. In an example, the PM 206 supports parity, error-correcting code (ECC) protection and reporting, or both parity and ECC. For example, the PM 206 can support 9-bit ECC and be able to correct a 1-bit error or 2-bit errors in a program instruction (e.g., 128 bits).
The core 202 can be directly coupled to the streaming interconnect 210 to receive input stream(s) and/or provide output stream(s). In addition, the core 202 can read and write data to the DM 208 in the DPE 200. As discussed further below, the core 202 in the DPE 200 can also access the DM in one or more neighboring tile circuits (e.g., north, south, east, and west neighboring tile circuits). In an example, as discussed further below, the core 202 can also include a direct connection with the data processing engine in one or more neighboring tiles for forwarding accumulator output (e.g., input and output cascading connection(s)). In an example, the core 202 sees the DM 208 in the DPE 200 and other DM(s) in neighboring tile(s) as one contiguous block of memory. The core 202 can also include an interface to the HW locks 218 and an interface to the debug/trace/profile circuitry 216. The debug/trace/profile circuitry 216 can include trace, debug, and/or profile circuitry.
The MM interconnect 212 can be an AXI memory-mapped interconnect or the like configured for transmission of data using address transactions between components. In an example, the MM interconnect 212 is used for configuration, control, and debugging functionality for the DPE 200. The MM interconnect 212 includes one or more switches that route transactions based on address. Circuitry can use the MM interconnect 212 to access the memory 204, the core 202, the DMA 220, and configuration registers in the DPE 200.
The streaming interconnect 210 can be an Advanced eXtensible Interconnect (AXI) streaming interconnect or the like configured for transmission of streaming data between components. The streaming interconnect 210 is used for transferring data between the DPE 200 and external circuits. The streaming interconnect 210 can support both circuit switching and packet switching mechanisms for both data and control.
In an example, as described further below, the DM 208 can include one or more memory banks (e.g., random access memory (RAM) banks). The DMA 220 is coupled between the streaming interconnect 210 and the DM 208. The DMA 220 is configured to move data from the streaming interconnect 210 to the DM 208 and move data from the DM 208 to the streaming interconnect 210. In this manner, an external circuit (e.g., a circuit configured in programmable logic or a circuit in an embedded processing system of the IC) can read data from and write data to the DM 208 through the streaming interconnect 210 using DMA. The DMA 220 can be controlled through the MM interconnect 212 and/or the streaming interconnect 210. In an example, the DM 208 supports parity, error-correcting code (ECC) protection and reporting, or both parity and ECC. For example, the DM 208 can support 9-bit ECC (e.g., 128-bits data).
The HW locks 218 could be used to lock particular memory banks of the DM 208 for access by the core 202, another data processing engine in another tile, or the DMA 220. The HW locks 218 provide synchronization between neighboring data processing engines in neighboring tiles, between the core 202 and the DMA 220, and between the core 202 and an external circuit (e.g., an external processor). The HW locks 218 can also be used to lock a particular buffer in the DM 208, which may be stored in one or more memory banks or in a portion of a single memory bank. The debug/trace/profile circuitry 216 is configured to provide debug, trace, and profile functions. The debug/trace/profile circuitry 216 can trace events generated by circuits in the DPE 200. The debug/trace/profile circuitry 216 can provide profile functionality, for example, configurable performance counters.
The DPE interconnect 209 includes a streaming connection 314W to a west tile, a streaming connection 314E to an east tile, a streaming connection 314N to a north tile, and a streaming connection 314S to a south tile. Each streaming connection 314 includes one or more independent streaming interfaces (e.g., busses), each having a specific bit width. The DPE interconnect 209 also includes a memory-mapped connection 312S from a south tile and a memory-mapped connection 312N to a north tile. Although only north and south MM connections are shown, it is to be understood that the DPE interconnect 209 can include other configurations for the MM interconnect (e.g., east-to-west, west-to-east, north-to-south, and the like). It is to be understood that the DPE interconnect 209 can include other arrangements of streaming and memory-mapped connections than shown in the example of
The compute circuitry 203 includes a connection 308W to memory circuitry in a west tile, a connection 308S to memory circuitry in a south tile, a connection 308N to memory circuitry in a north tile, and a connection 308E to the memory module 351. The compute circuitry 203 include a streaming interface to the DPE interconnect 209. The compute circuitry 203 also includes a connection 310A from a core in the west tile and a connection 310B to a core in the east tile (e.g., cascading connections). It is to be understood that the DPE can include other arrangements of memory and cascading connections than shown in the example of
The mem IF 302W is coupled to the memory connection 308E of the compute circuitry 203. The mem IF 302N is coupled to a memory connection of the data processing engine in the north tile. The mem IF 302E is coupled to a memory connection of the data processing engine in the east tile. The mem IF 302S is coupled to a memory connection of the data processing engine in the south tile. The mem IF 302W, 302N, 302E, and 302S are coupled to the RAM banks 318. The DMA 220A includes an output coupled to the DPE interconnect 209 for handling memory to interconnect streams. The DMA 220B includes an input coupled to the DPE interconnect 209 for handling interconnect to memory streams. The regs 304 and the regs 306 are coupled to the DPE interconnect 209 to receive configuration data therefrom (e.g., using the memory-mapped interconnect).
The stream switch 402 includes first-in-first-out (FIFO) circuits (FIFOs 412) and registers (regs 410). The FIFOs 412 are configured to buffer streams passing through the stream switch 402. The regs 410 store configuration data for the stream switch 402 that controls the routing of streams through the stream switch. The regs 410 can receive configuration data from the MM switch 404. The stream switch 402 can include an additional interface to the compute circuitry 203 and an additional interface to the DMA circuitry 220. The stream switch 402 can send and receive control streams and receive trace streams (e.g., from the debug/trace/profile circuitry 216).
The computer 501 further includes a software platform comprising an operating system (OS) 522 and a design tool 510. The OS 522 and the design tool 510 include instructions that are executed by the CPU 502. The OS 522 can include any known operating system, such as Linux®, Microsoft Windows®, Mac OS®, and the like. The design tool 510 is an application that executes within the OS 522, which provides an interface to the hardware platform 518. Operation of the design tool 510 is discussed below. An example design tool that can be adapted to include the techniques described herein is the Vivado® Design Suite available from Xilinx, Inc. of San Jose, Calif., although other circuit design tools can be similarly adapted.
Compiler Flow for a Heterogeneous Multi-Core Architecture
In the example, the input circuit 702 comprises digital logic (and optionally analog logic) configured to communicate with external systems/circuits, as well as provide data to the kernel 704 for processing. The input circuit 702 maps to the PL 122. Likewise, the output circuit 708 comprises digital logic (and optionally analog logic) configured to communicate with external systems/circuits, as well as receive data from the kernel 706 that has been processed. The output circuit 708 maps to the PL 122. In an example, the kernels 704 and 706 comprise a programmatic description of data processors. The kernels 704 and 706 map to the DPE array 105. The control software 710 is a programmatic description of a controller for the kernels 704 and 706. In an example, the control software 710 maps to the PS 130.
Returning to
The implementation output 614 is configured for implementation on target platforms 626. The target platforms 626 include simulation platforms (“simulation 628”), emulation platforms (“emulation 630”), and hardware platforms (“hardware 632”). The hardware 632 includes the SOC 100. The simulation and emulation platforms 628 and 630 simulate/emulate the hardware 632.
The user-defined graph description 802 can be specified using various programming languages (e.g., C, C++, etc.) or data structure languages (e.g., XML, JSON, etc.). One example of the user-defined graph description 802 specified in C++ is shown below:
using namespace cardano;
class radio:
cardano::graph {
public:
cardano::kernel a,b,c,d,e,f;
radio( ){
a=kernel::create(polarclip);
b=kernel::create(feedback);
c=kernel::create(equalizer);
d=kernel::create(fir_tap11);
e=kernel::create(fir_tap7);
f=kernel::create(scale);
fabric<fpga>(a);
fabric<fpga>(f);
connect<stream, window<64,8>> (a.out[0], b.in[0]);
connect<window<32>> (b.out[0], c.in[0]);
connect<window<32, 24>> (c.out[0], d.in[0]);
connect<window<32, 16>> (d.out[1], e.in[0]);
connect<window<32, 8>> (e.out[0], b.in[1]);
connect<window<16>, stream> (d.out[0], f.in[0]);
}
}
In the example above, the radio class is derived from a class library (cardano) with graph building primitives. Using these primitives, the user-defined graph description 802 defines compute nodes a, b, c, d, e, and f. The compute nodes a and f are circuits mapped to the PL 122. The compute nodes b, c, d, and e are kernels mapped to the DPE array 105. The circuit a is connected to the kernel b using a DMA streaming connection. The kernel b is connected to the kernel c; the kernel c is connected to the kernel d; the kernel d is connected to the kernel e; and the kernel e is connected to the kernel b, where each such connection is through memory blocks in the DPE 105. The kernel d is connected to the circuit F through a DMA streaming connection.
The user-defined graph description 802 can also include a top-level description of the platform. For example:
radio mygraph;
simulation::platform<1, 1> platform(“in.txt”, “out.txt”);
connect< > net0(platform.src[0], mygraph.in);
connect< > net1(platform.sink[0], mygraph.out);
In the example above, the user instantiates the radio class (mygraph) and sets up a simulation target. The user can also specify a control program for execution on the PS 130, such as:
int main(void) {
mygraph.init( )
mygraph.run( )
mygraph.end( )
return 0;
}
In the example above, the user initializes mygraph, executes mygraph, and ends mygraph for purposes of simulation in the simulation platform.
The kernel source code 804 provides a source code description for each compute node targeting a DPE 110 (e.g., compute nodes b, c, d, and e in the example above). The kernel source code 804 can be defined using any programming language (e.g., C, C++, etc.). Example C++ source code for defining the compute node c (equalizer) is shown below:
void equalizer (input_window_cint16*inputw, output_window_cint16*outputw) {
. . .
v32cint16 sbuff=null_v32cint16( )
for (unsigned i=0; i<LSIZE; i++)
{
}
}
In the example, the compute node c (equalizer) is implemented using a C/C++ function with input parameters defining the input of the compute node. The code includes pragmas to assist in scheduling for performance. The code includes intrinsics for performing vectorized computations and application programming interfaces (APIs) for accessing data.
The front end 806 is configured to process the user-defined graph description 802 and generate a directed graph as an internal representation. In the directed graph, nodes represent compute nodes and edges represent connections between compute nodes. The mapper 808 is configured to implement the directed graph for a DPE array 105 in a target device based on a device description 814. The mapper 808 partitions the compute nodes into groups, and maps the partitioned compute nodes to DPEs 110. The backend 810 is configured to route the connections between DPEs 110 and circuits in the PL 122, then invoke the single core compiler 812 to generate DPE binaries, and also generate stream switch and DMA configuration code based on the output of the mapper 808.
The method 1100 begins at step 1102, where the DPE array compiler 604 parses the application 608 and generates a directed graph based on a user-defined graph description of the design. In an example, the DPE array compiler 604 identifies the compute nodes 902-912 and connections between them. The DPE array compiler 604 then forms a graph where the nodes are the kernels and the edges are connections, as shown in
At step 1104, the DPE array compiler 604 processes the directed graph to cluster kernels into groups that can execute on a core in a data processing engine. In the example, the kernels are selected from compute nodes B 904, C 906, D 908, and E 910. That is, each DPE 110 can execute one or more kernels and the DPE array compiler 604 determines which of the kernels can be combined for execution as groups. As shown in
At step 1106, the DPE array compiler 604 processes the code defining each the kernels for optimization to improve performance and reduce memory footprint of the kernel clusters. At step 1108, the DPE array compiler 604 maps the kernels (or kernel clusters if any) onto the DPEs 110 in the DPE array 105. As shown in
At step 1110, the DPE array compiler 604 maps data structures defined in the kernel code onto local memory banks in the corresponding DPEs 110 or to DMA for non-local communication. As described above, DPEs in proximity with each other can share memory banks. Communication through shared memory can be single buffered or double buffered as described further herein. However, in some cases, a DPE may be far enough from another DPE such that the kernels executing thereon require DMA communication. As shown in
At step 1112, the DPE array compiler 604 allocates communication channels between the DPE array 105 and the PL 122. For example, communication channels to input/output circuitry configured in the PL 122 (e.g., compute nodes a and f). For example, as shown in
At step 1114, the DPE array compiler 604 allocates locks for core-to-core and core-to-DMA (if necessary) synchronization among the kernels. As shown in
At step 1116, the DPE array compiler 604 routes the stream data communication between cores and to/from the PL 122 via stream switches (e.g., circuit-switched and/or packet-switched). At step 1118, the DPE array compiler 604 generates wrapper code for each DPE 110 and compiles the wrapper code to generate DPE binaries. At step 1120, the DPE array compiler 604 generates control code to configure the DMAs stream switches. At step 1122, the DPE array compiler 604 generates application programming interfaces (APIs) for the control software executing on the processing system to access and control the kernels executing in the data processing engine array.
Heuristic Partitioner
In the method 1100 described above, the DPE array compiler 604 clusters kernels into groups that can execute on DPEs 110 (step 1104). Computationally, the partitioning problem is non-polynomial (NP) hard, which follows from the reduction of the classic problem of bin packing with conflicts to the partitioning problem. In examples herein, for tractability, greedy heuristics are used in the partitioning algorithm In the graph-based programming model, each kernel has an associated runtime ratio, which denotes an upper bound on its execution time compared to the cycle budget. The sum total of runtime ratio of the kernels clustered together must not exceed one. Additionally, the user can also specify co-location constraints between kernels, or absolute location constraints on a kernel, which influences the allocation of kernels to a partition and the mapping of kernels/partitions to the data processing engines. Compare to prior efforts, the partitioning scheme described herein is unique in that it handles a wide variety of constraints encompassing absolute, relative, and derived constraints. The techniques also dynamically infer some constraints while creating the partitions, so that a feasible partition-to-core mapping can be found. Further, the techniques allow the user to choose among different partitioning heuristics, each with a multi-criteria objective function.
At step 1206, the DPE array compiler 604 sorts the nodes in the graph based on their runtime ratio, and criticality. This is done in two steps. First, the DPE array compiler 604 sorts the nodes based on their static level to create list L1. The static level for a node n is computed as the maximum cumulative runtime ratio from n to any sink in the graph. Then the DPE array compiler 604 scans L1 to find an unexplored node m. With m as the root, it performs a reverse postorder (RPO) traversal, while prioritizing exploration in a depth-first manner. The description terms this traversal depth-prioritized RPO. All the nodes explored in the RPO traversal are appended to a new list L2. Then a new unexplored node is chosen from L1, and step 1206 is repeated until all the nodes in L1 are explored. The RPO traversal exploits locality, increases the probability of placing producer-consumer kernels in the same partition, and increases the probability that the critical path is not worsened.
At step 1208, the DPE array compiler 604 processes the sorted nodes one at a time and places them into final partitions. Each node can be placed in an existing partition or in a new partition. The assignment is performed by determining the constraints between the selected kernel and the existing kernels in each partition. For example, the DPE array compiler 604 maintains the runtime ratio of each partition to be less than or equal to one (e.g., so that a give data processing engine does not become overcommitted) (step 1210). Thus, a kernel k_a cannot be assigned to a partition b_a if the sum of the runtime ratios of the kernels in b_a and the runtime ratio of the kernel k_a exceeds one.
In another example, a partition that has a kernel with an absolute constraint inherits the absolute constraint (step 1212). Thus, if a kernel k_a has an absolute constraint that pins the kernel to a particular data processing engine, and the partitioning algorithm maps k_a to partition b_a, then the absolute constraint of k_a extends to the partition b_a. Afterwards, the DPE array compiler 604 does not add a different kernel k_b to the partition b_a, where k_b has an absolute constraint that maps it to a different data processing engine than k_a.
In another example, the DPE array compiler 604 ensures that the partitions satisfy physical constraints of the data processing engine array (step 1214). For example, a partition cannot have more than a defined number of input/output stream ports for the given architecture. Two kernels in the same partition cannot have particular types of connections between them, such as stream, cascade, or asynchronous connections.
In another example, the DPE array compiler 604 satisfies any dynamic location constraints arising from the partitioning process (step 1216). As the partitioning progresses, some location constraints may dynamically arise between two partitions that have crossing double-buffer data edges. Such partitions may need to be mapped to adjacent data processing engines in the array.
In step 1208, the partitioning algorithm keeps track of all constraints and honors them while assigning kernels to partitions. If a kernel cannot be added to any pre-existing partition due to constraint conflict, then the DPE array compiler 604 creates a new partition. However, if there are multiple partitions to which a kernel can be added, there are two possibilities: (1) the DPE array compiler 604 can add the kernel to one of the pre-existing partitions; or (2) the DPE array compiler 604 can add the kernel to a new partition. The first option minimizes the number of opened partitions, which has direct implications on power consumption. The second option can help to reduce the overall execution latency. Since the user may have different objectives for different applications (e.g., reducing power usage versus reducing execution time), the DPE array compiler 604 can provide two implementations for the user: (1) one that minimizes the number of partitions, i.e., that would add the kernel to one of the conflict-free pre-existing partitions whenever possible; and (2) one that adds the kernel to a conflict-free partition only if it does not worsen the critical path length, otherwise a new partition is created. In both cases, should the algorithm decide that the kernel can be added to multiple partitions, priority is given to the partition that minimizes the number of double buffer edges across partitions.
At step 1218, the design tool determines an execution order of kernels in each partition based on criticality. After partitioning, the kernels in each partition are to be executed sequentially. In order to avoid an increase in execution latency, the kernels in a given partition are executed based their criticality.
Some constraints of the partitioning problem can also be formulated as an integer linear programming (ILP) problem, which can be solved by using an ILP solver. However, not all of the constraints/objective functions can be effectively represented in ILP and the solution may well be exponential in time. The heuristic-based partitioner described herein is greedy and therefore linear in time. Partitioning is done in tandem with mapping. Alternatively, partitioning and mapping can be done concurrently.
In particular, the DPE array compiler 604 determines a set R of existing partitions to which n can be added. At step 1312, the DPE array compiler 604 sorts the partitions R in descending order of buffers shared with n. As described above, some kernels can share memory buffers with other kernels. At step 1314, the DPE array compiler 604 picks the first partition r in the sorted R so that a merge of n with r does not: (1) worsen the critical path or (2) lead to an infeasible topological placement.
At step 1316, the DPE array compiler 604 determines if r is empty (i.e., there is no existing partition for n). If not, the method 1300 proceeds to step 1318, where the DPE array compiler 604 merges the node n with the partition r and updates the location constraints of the partition r based on the node n (e.g., any absolute and/or relative constraints defined for n). If r is empty, the method 1300 proceeds instead to step 1320, where the DPE array compiler 604 creates a new partition, adds n to the new partition, and updates the location constraints of the new partition based on n. The method 1300 proceeds from either step 1318 or the step 1320 to step 1304 and repeats until all nodes have been processed.
Mapping
As described above in step 1108, the DPE array compiler 604 maps kernels and kernel clusters onto DPEs 110. Input to the mapping algorithm is a static directed graph (e.g.,
At step 1406, the DPE array compiler 604 inserts additional buffers in the directed graph to provide for DMA communication between kernels within the DPE array 105. At step 1408, the DPE array compiler 604 performs a second pass of mapping having the DMA communication links. The second pass of mapping can be executed faster than the first pass because the solution from the first mapping pass can be used as a starting point. Thus, the DPE array compiler 604 need only place the newly inserted buffers for DMA communication. The method 1400 then ends at step 1410.
Both mapping passes (1402 and 1408) solve an ILP based optimization problem with heuristic cost objectives. The objectives of the optimization problem are (1) minimize the number of data movements; 2) minimize memory conflicts; and 3) minimize latency.
Data movement optimization: Each core 202 in a DPE 110 can access memory modules 351 on all cardinal sides (North, South, East, and West) as shown in
The DPE array compiler 604 models the DPE array 105 as a checkerboard architecture using a cost model where each core's neighboring memory modules have zero access cost and the remaining memory modules have higher cost. The optimization problem is then to map kernels to cores and buffers to memory modules with minimal cost. The problem is naturally expressible as a quadratic optimization problem. The DPE array compiler 604 works to reduce the quadratic problem to an ILP problem.
Memory conflict optimization: Each memory module 351 includes RAM banks 318 (e.g., eight banks of RAM). When there are multiple accesses to the same RAM bank in the same cycle, there is a memory access conflict. Memory access conflicts can be classified into different types: (1) Intra-core memory access conflict; (2) inter-core memory access conflict; (3) core-DMA memory access conflict; and (4) DMA-DMA memory access conflict. For intra-core memory access conflict, the cores execute very large instruction word (VLIW) instructions. Each VLIW instruction can have multiple memory access instructions (e.g., up to two loads and one store). If two or more memory operations in a single instruction access the same memory bank, it will cause a memory stall and in turn a core stall. Two or more different cores accessing the same memory bank in the same cycle cause inter-core memory access conflict. A core and DMA channel access the same memory bank in the same cycle cause a core-DMA memory access conflict. Multiple DMA channels accessing the same memory bank in the same cycle cause a DMA-DMA memory access conflict.
Since completely avoiding conflicts may not be possible for all applications, the DPE array compiler 604 allows the user to choose from a set of conflict avoidance and conflict minimization settings. The DPE array compiler 604 makes the distinction between local buffers (e.g., buffers that are accessed by a single kernel) and shared buffers (e.g., buffers that are accessed by multiple kernels) and performs different optimizations. The DPE array compiler 604 takes a two-pronged approach to address memory conflicts: 1) conflict avoidance; and 2) conflict minimization. For conflict avoidance, to avoid access conflicts between the producer and consumer of a data block, the DPE array compiler 604 ensures that double buffers (e.g., ping buffer and pong buffer) are mapped to different RAM banks. Similarly, the DPE array compiler 604 ensures that there are no conflicts between accesses of local buffers from different kernels by placing them on different banks. Intra-core memory conflicts are avoided by placing all buffers accessed by a single kernel on different RAM banks 318.
For conflict minimization, the problem is reduced to the problem of minimizing the number of independent actors (cores, DMA channels) that are accessing a given memory bank. Modeling this as an ILP problem can be expensive for large devices, sine the number of cores and DMA channels are proportional to c times r, where c is the number of columns and r is the number of rows in the DPE array 105 of the device. The DPE array compiler 604 employs a technique to reduce the number of ILP variables by modeling all DMA channels as two distinct actors (a reader and a writer) instead of c×r×4 different entities.
Latency minimization: Similar to FPGA placement algorithms, the DPE array compiler 604 minimizes the latency of stream-based communication by minimizing the distance between the source and sink.
Stream FIFO Insertion in a Heterogeneous Multi-Core Architecture
FIFO determination and insertion for deadlock-avoidance and performance has been researched in the past, but largely in the context of theoretical models of computation (e.g., synchronous data flow, Kahn Process networks) and high-level synthesis. This problem has not been solved for multi-processor systems, largely because there are few such systems that communicate with each other using elastic, handshake streams (e.g., most multi-processor systems use shared memory for data communication or are systolic arrays that work in lock-step).
A theoretical analysis of this for the general case is difficult and conservative, which can lead to very large FIFOs. Thus, in an example, the DPE array compiler 604 implements a simulation-based approach. The DPE array compiler 604 simulates the system with selected FIFO sizes until deadlock/performance failures are avoided (step 1508). The simulation can be at different levels of abstraction: compute-kernel code may be untimed, but kernels run concurrently (“untimed and concurrent execution of the kernels); or kernels may be modeled in a cycle-accurate manner (“cycle-accurate concurrent execution of the kernels).
Once the FIFO sizes are determined at step 1506, the FIFOs need to be inserted along the stream routes between the producer and consumer compute-kernels (step 1510). In the DPE array 105, there are two options: each stream switch has two FIFOs of limited size (e.g., 16 words each); or local data memory can be used as FIFOs via the tile-DMA engine. The latter option is needed if the FIFO sizes are very large. With the former option, one complication is that the number of stream switches along a producer-to-consumer route limits the total number of limited-size FIFOs that can be used. So the route itself may need to be artificially lengthened in order to meet the total specified or determined FIFO size. Another complication is that multiple routes may share a stream switch. Therefore, the heuristic to distribute the specified or determined FIFO length along the routes' stream switches accounts for such sharing. Thus at step 1512, the DPE array compiler 604 can select FIFOs in the DPE interconnect. In addition or alternatively, at step 1514, the DPE array compiler 604 can implement FIFOs in local memory. The method 1500 then ends at step 1516.
At step 1810, the DPE array compiler 604 selects a path to process. At step 1812, the DPE array compiler 604 annotates the edges with a FIFO requirement along the node order until a feasible FIFO placement is reached. In some cases, the DPE array compiler 604 “retimes” as much common FIFO as possible to reach feasibility while still satisfying the FIFO requirement (step 1814). For example, consider the path between the data source 1602 and the DPE 1604C. When processing this path, the DPE array compiler 604 may assign a FIFO of depth 10 between the nodes 1704 and 1706, and a FIFO of depth 10 between the node 1706 and the DPE 1604C. This would satisfy the FIFO requirements of both the DPEs 1604B and 1604C. However, when processing the path between the data source 1602 and the DPE 1604D, the DPE array compiler 604 may retime the FIFO between the data source 1602 and the node 1704 from a depth of 0 to a depth of 10, and retime the FIFO between the nodes 1704 and 1706 from a depth of 10 to a depth of 0. The result is shown in
In an example, at step 1802, the DPE array compiler 604 performs a whole graph analysis to determine an order for the paths to be processed. Instead of looking at one path at a time to assign a FIFO, the DPE array compiler 604 can look at all paths that require FIFO insertion. The DPE array compiler 604 can then sort the paths in ascending order of size of the paths (step 1804) in terms of the number of nodes along the paths. If paths have equal numbers of nodes, the DPE array compiler 604 can sort based on the FIFO depth of the path in order of smallest depth to largest depth.
In an example, at step 1806, the DPE array compiler 604 reorders the nodes along each path identified in step 1804. A degree of a node is defined as a total number of times a node is used across all of the paths. The DPE array compiler 604 can sort the nodes in ascending order of degree. By performing whole graph analysis and node ordering ahead of FIFO determination, the method 1800 can move the common FIFO depth towards the data source while being able to update the depths near the DPEs. Further, the method 1800 can handle broadcast from the FIFO ports.
In the example of
In the example of
The DPE array compiler 604 then performs steps 1810 through 1816 by processing the paths in the determined order, and in the determined node order for each path. The result is shown in
Routing of Connections Among Cores in a DPE Array
Routing between cores in the DPE array can be achieved by greedily allocating channels to routes that require communication with the PL 122. Being a greedy heuristic, this approach exposes the limitations when routing larger graphs or when requiring handling special constraints. The prior approach does not support handling architectural constraints, packet switching, and handling channels that require upsize/downsize conversion and routing for explicit packet switching in the programming model. Techniques are described herein for routing that handles these requirements.
The following terminology is introduced for use in describing the routing techniques described herein for routing an application mapped to the DPE array 105. Routing node: A node in a routing graph that represents a source or destination of data or an intermediate switch. Node capacity: An integer representing the maximum allowed flow of data through a node. Routing edge: A routing edge represents a potential flow of data from a source to the destination. Routing graph: A routing graph represents all possible routing choices. These choices model the architecture switching constraints, routing constraints imposed by the user defined shim constraints, constraints for upsizing/downsizing channels, and programmer defined constraints through explicit packet split and merge operations. Net: A net represents a desired routing with a source node in the routing graph and multiple destinations in the routing graph. Net utilization: An integer that models bandwidth required by a net. Nets of low bandwidth can be routed together by sharing switching resources.
At step 1904, the DPE array compiler 604 models PL connections. Since the output of a PL node can be connected to any of the shim ports, the DPE array compiler 604 models each PL connection as a cross-bar connection from the PL source to all the channels in the shim. If the user specifies specific constraints on the shim channels, the cross-bar connections can be specialized to the set of given shim constraints.
At step 1906, the DPE array compiler 604 models upsizer/downsizer connections. The shim architecture allows higher bit-width channels running at lower frequency to be connected lower bit-width channels running at higher frequency. The shim channels have a fixed bit-width so implementing some higher bit-width channels requires use of multiple adjacent shim channels. The architecture further puts a restriction that the group of shim channels must be allocated on an even boundary. These constraints are incorporated by modifying the routing graph with new nodes and edges. The constraint is expressed by replacing cross-bar connections to all shim channels with limited connectivity.
At step 1908, the DPE array compiler 604 models other constraints. Some constraints are not easily expressible as connections in the routing graph. These are expressed as additional global constraints on the nets and resource routes. For example, an architecture constraint may be allowing four packet switch nets passing through every switch port. Another example is to allow only one net to pass through a shim channel even though the bandwidth utilization is low. Merging of explicit packet switched nodes early or late are handled using the constraint mechanism.
At step 1910, the DPE array compiler 604 invokes a satisfiability solver (SAT solver) to route the application in the DPE array 105. The input specification graph is examined for nets that require routing. The source and destination of the net are identified. The source or destination net must be nodes in the routing graph. For enabling packet switching, net utilization is provided by the user. All the nets in the input specification are passed together to the SAT solver along with the constraints. The solution provided by the SAT solver is used to program the stream switches of the DPE array 105 (e.g., the stream switch configuration code 616).
In some FPGAs, each programmable tile can include at least one programmable interconnect element (“INT”) 43 having connections to input and output terminals 48 of a programmable logic element within the same tile, as shown by examples included at the top of
In an example implementation, a CLB 33 can include a configurable logic element (“CLE”) 44 that can be programmed to implement user logic plus a single programmable interconnect element (“INT”) 43. A BRAM 34 can include a BRAM logic element (“BRL”) 45 in addition to one or more programmable interconnect elements. Typically, the number of interconnect elements included in a tile depends on the height of the tile. In the pictured example, a BRAM tile has the same height as five CLBs, but other numbers (e.g., four) can also be used. A DSP tile 35 can include a DSP logic element (“DSPL”) 46 in addition to an appropriate number of programmable interconnect elements. An 10B 36 can include, for example, two instances of an input/output logic element (“IOL”) 47 in addition to one instance of the programmable interconnect element 43. As will be clear to those of skill in the art, the actual I/O pads connected, for example, to the I/O logic element 47 typically are not confined to the area of the input/output logic element 47.
In the pictured example, a horizontal area near the center of the die (shown in
Some FPGAs utilizing the architecture illustrated in
Note that
While the foregoing is directed to specific examples, other and further examples may be devised without departing from the basic scope thereof, and the scope thereof is determined by the claims that follow.
| Number | Name | Date | Kind |
|---|---|---|---|
| 5504894 | Ferguson | Apr 1996 | A |
| 5848264 | Baird et al. | Dec 1998 | A |
| 6090156 | MacLeod | Jul 2000 | A |
| 7080283 | Songer et al. | Jul 2006 | B1 |
| 7657861 | Vorbach | Feb 2010 | B2 |
| 8209653 | Vorbach | Jun 2012 | B2 |
| 8250503 | Vorbach | Aug 2012 | B2 |
| 8719808 | Prinzing | May 2014 | B1 |
| 9578099 | Llorca et al. | Feb 2017 | B2 |
| 10628622 | Sivaraman | Apr 2020 | B1 |
| 10860766 | Sivaraman | Dec 2020 | B1 |
| 20020133325 | Hoare, II | Sep 2002 | A1 |
| 20050108419 | Eubanks | May 2005 | A1 |
| 20060156266 | Alpert | Jul 2006 | A1 |
| 20080114937 | Reid et al. | May 2008 | A1 |
| 20100161938 | Heddes | Jun 2010 | A1 |
| 20100322237 | Raja et al. | Dec 2010 | A1 |
| 20160132765 | Alpert | May 2016 | A1 |
| 20170161419 | Ganusov et al. | Jun 2017 | A1 |
| 20170195258 | Wang et al. | Jul 2017 | A1 |
| 20170207998 | Fraisse | Jul 2017 | A1 |
| 20170220499 | Gray | Aug 2017 | A1 |
| 20170364473 | Singh et al. | Dec 2017 | A1 |
| 20190057305 | Denolf et al. | Feb 2019 | A1 |
| 20200372200 | Sivaraman | Dec 2020 | A1 |
| Entry |
|---|
| “Xilinx Unveils Revolutionary Adaptable Computing Product Category”, Xilinx, Inc., Mar. 19, 2018,(https://www.xilinx.com/news/press/2018/xilinx-unveils-revolutionary-adaptable-computing-product-category.html). |
| “Versal: The First Adaptive Computer Acceleration Platform (ACAP)”, Xilinx, Inc., WP505 (v1.0), Oct. 2, 2018 (https://www.xilinx.com/support/documentation/white_papers/wp505-versal-acap.pdf). |
| Bokhari, S.H., “On the mapping problem,” IEEE Transactions on Computers, Mar. 1981, vol. 1, No. 3, pp. 207-214. |
| Xilinx, “Xilinx AI Engines and Their Applications,” WP506 (v1.0.2), Oct. 3, 2018, 13 pg., Xilinx, Inc., San Jose, California, USA. |
| Xilinx, “SDAccel Development Environment User Guide,” UG1023 (v.2015.1), Sep. 15, 2015, 95 pg., Xilinx, Inc., San Jose, California, USA. |
| Xilinx, “Versal Architecture and Product Data Sheet: Overview,” DS950 (v1.0), Oct. 2, 2018, 23 pg., Xilinx, Inc., San Jose, California, USA. |
| Roman Brillu etal, “Flextiles”, Rapid Simulation and Performance Evaluation, ACM, 2 Penn Plaza, Suite 701, NY, NY 10121-0701 USA, Jan. 22, 2014. |
| Jaume Bosch et al., Exploiting Parallelism on GPUs and FPGAs iwth OmpSs, Proceedings of the 1st Workshop on Autotuning and Apadtivity Approaches for Energy Efficient HPC Systems, Andare17, Jan. 1, 2017. |
| Ingrid Verbauwhede et al., “Architectures and Desgin techniques for energy efficient embedded DSP and multimudia processing” ACM 2 Penn Plaza, Suite 701, NY, NY Jan. 1, 2004. |
