Instructions to configure coarse-grained reconfigurable array to execute program of data stream
Through new assembly languages and software tools, data flow synchronization and hardware scheduling challenges when traditional assembly languages are executed in coarse-grained reconfigurable arrays are solved, enabling efficient heterogeneous computing, improving performance and efficiency.
Patent Information
- Application Number
- CN202380029351.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2022-03-25
- Filing Date
- 2023-03-08
- Publication Date
- 2024-11-08
AI Technical Summary
Traditional assembly language programming is difficult to effectively utilize heterogeneous computing elements when performed in configuration coarse-grained reconfigurable arrays, especially with challenges in data flow synchronization and hardware detail scheduling, resulting in performance and efficiency issues.
Using a new assembly language, data flow is described through graph groups, the parser maps it to a coarse-grained reconfigurable array, uses synchronous and asynchronous structures to achieve efficient execution of data flows, and is automated through software tools. Configure and schedule to ensure instructions are executed on the correct clock cycle.
It improves the performance and power consumption ratio of data-intensive applications, simplifies programmers' programming process, reduces debugging complexity, and achieves more efficient hardware resource utilization and automated execution configuration generation.
Smart Images

Figure CN118922824A_ABST
Abstract
Description
[0001] Related Applications
[0002] This application claims priority to U.S. Patent Application No. 17 / 705,091, filed on March 25, 2022, and entitled “Configure a Coarse Grained Reconfigurable Array to Execute Instructions of a Program of Data Flows,” the entire disclosure of which is hereby incorporated by reference herein. Technical Field
[0003] At least some embodiments disclosed herein relate generally to configuring a computing device to execute instructions of a computer program and more particularly, but not limited to, configuring a computing device having circuit tiles for parallel execution. Background Art
[0004] Conventionally, assembly language programming is based on specifying operations to be performed on data stored in registers. A typical opcode is specified to identify the operation to be performed on data stored in one or more registers identified for the opcode; and the result of the operation is to be stored in the register identified for the opcode.
[0005] To execute this traditional assembly language program, the virtual registers referenced in the program are mapped to physical registers in the processor for executing the program. When there are fewer physical registers than virtual registers referenced in the program, values are shifted back and forth among the physical registers to implement register reuse and satisfy the virtual register usage in the program. BRIEF DESCRIPTION OF THE DRAWINGS
[0006] The embodiments are illustrated by way of example and not limitation in the figures of the accompanying drawings in which like reference numerals indicate similar elements.
[0007] Figure 1 The structure of an assembly language program for execution in a coarse-grained reconfigurable array according to one embodiment is described.
[0008] Figure 2 Description According to one embodiment, an assembly language program is generated using a compiler.
[0009] Figure 3 A coarse-grained reconfigurable array is described in which an assembly language program according to one embodiment may be configured to specify operations.
[0010] Figure 4 Dispatching interface information of an assembly language program according to one embodiment is described.
[0011] Figure 5 Memory interface information of an assembly language program according to one embodiment is described.
[0012] Figure 6 The block memory information of an assembly language program according to one embodiment is described.
[0013] Figure 7 A method of specifying operations in a coarse-grained reconfigurable array according to one embodiment is presented.
[0014] Figure 8 An instruction execution schedule generated from an assembly language program according to one embodiment is described.
[0015] Fig. 9 A memory map for implementing an assembly language program in a coarse-grained reconfigurable array according to one embodiment is described.
[0016] Fig.10 An execution configuration of a coarse-grained reconfigurable array for running an assembly language program according to one embodiment is described.
[0017] Fig.11 A method for identifying a configuration of a coarse-grained reconfigurable array to run an assembly language program is presented according to one embodiment.
[0018] Fig.12 A block diagram showing an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION
[0019] At least some embodiments disclosed herein provide techniques for configuring a coarse-grained reconfigurable array to run an assembly language program that specifies data flow through memory locations represented by memory variables.
[0020] A near memory computing (CNM) architecture can be used to exploit the tremendous opportunities provided by high performance communication protocols such as the Compute Express Link (CXL) protocol. This near memory computing (CNM) architecture can incorporate heterogeneous computing elements into a memory / storage subsystem to accelerate various near data computing tasks. An example of such a computing element is a streaming engine (SE) implemented via a coarse-grained reconfigurable array (CGRA) having interconnected computing tiles. The tiles are interconnected with both a synchronous fabric (SF) and an asynchronous fabric (AF). The synchronous fabric (SF) can be configured to connect each tile to an adjacent tile separated by one or two clock cycles. The synchronous fabric (SF) interconnects elements within each tile, such as tile memories, multiplexers, and single instruction multiple data (SIMD) units, etc. The tiles can be pipelined by the synchronous fabric (SF) to form a synchronous data flow (SDF) through a single instruction multiple data (SIMD) unit for operations such as multiplication / shift, addition / logical operations, etc. Each slice may have a pipeline time multiplexing processing unit so that a new instruction may be started on each slice at each clock cycle. An asynchronous fabric (AF) connects a slice with other slices, a dispatch interface (DI), and a memory interface (MI). An asynchronous fabric (AF) bridges synchronous data flows (SDF) through asynchronous operations, which include the initiation of synchronous data flows, asynchronous data transfer from one synchronous data flow to another, system memory access, and branch and loop construction. Each slice may have a delay register to save its output to be output in alignment with the execution of instructions using the output. Together, the synchronous fabric (SF) and the asynchronous fabric (AF) allow slices to efficiently execute high-level programming language constructs. Simulation results of a hand-crafted streaming engine (SE) kernel show that the performance-to-power ratio of data-intensive applications is improved by several orders of magnitude compared to existing computing platforms.
[0021] However, it is challenging to apply traditional compilation tools to program operations of new architectures, such as streaming media engines (SEs) implemented using coarse-grained reconfigurable arrays (CGRAs). In a dataflow-based coarse-grained reconfigurable array (CGRA), programs work by causing data to flow from one tile to another in a synchronized manner. This requires programming instructions with precise cycles on the correct tiles to avoid corrupting the synchronized flow of operations. At least some embodiments discussed in the present disclosure use a new assembly language with a corresponding parser that can describe a program as a graph group representing a dataflow, rather than deforming the dataflow to pretend it is a sequence of register transfers as in traditional assembly.
[0022] Configuring the streaming engine (SE) requires finding a synchronization schedule for instructions so that streaming can start for a data element and each subsequent instruction is aligned on a valid tile with the correct cycle. The assembly language of at least some embodiments discussed in this disclosure facilitates determining this synchronization schedule. It can be used to describe some configuration details of the hardware and the data flow of the calculation.
[0023] In one embodiment, the assembly language is configured to describe the details of a program for a streaming media engine (SE). For example, a dispatch interface (DI) block of the program may be configured to specify information about a dispatch interface of the streaming media engine (SE); a memory interface (MI) block may be configured to specify information about memory operations implemented via a memory interface of the streaming media engine (SE); a tile memory (TM) block may be configured to specify information about memory variables to be mapped to a tile memory of the streaming media engine (SE); and a stream block may be configured to specify a graph group representing a synchronized data stream.
[0024] Optionally, the user describes the computations to be performed by the streaming engine (SE) according to the configuration details specified using the dispatch interface (DI) block, the memory interface (MI) block, and the tile memory (TM) block, and the program details specified via the stream block. When this assembly language program is run, it can be parsed, mapped, and reduced to the program execution configuration of the streaming engine by software tools.
[0025] Optionally, a compiler may be used to automatically convert a computer program written in a high-level programming language into an assembly language program according to the present disclosure.
[0026] The disclosed assembly language program technology has multiple advantages. For example, representing configuration and data flow allows the assembly to reflect the state of the device. For example, programming the data flow allows the programmer to work according to the way data moves between operations, rather than scheduling hardware details between tiles. For example, decomposing the code into separate synchronization streams allows the programmer to explicitly define the asynchronous message transmission that occurs between synchronization elements. For example, programming the device with the abstract representation of the assembly language is much faster than working with the low-level details of specifying the operation of multiplexers and tile connections. For example, the parser can provide more friendly error message transmission for typos and inconsistent logic, rather than debugging why the device simulation is not terminated or providing incorrect answers. For example, defining the assembly language opens the possibility of using mainstream compiler tools to compile high-level code down to this more abstract description of the device in the future. For example, since the program is an instruction list, high-level and low-level knobs can be provided to the programmer through the instruction representation. For example, low-level types of instructions allow programmers to specify individual fields / operation codes that end in instructions; or, high-level formats based on operations rather than fields can be used.
[0027] An assembly language program describing a data flow may be mapped for execution on a specific coarse-grained reconfigurable array (CGRA). A coarse-grained reconfigurable array (CGRA) may have a specific structure (e.g., a number of tiles and a memory interface) and a specific interconnectivity of a synchronous fabric (SF) and / or an asynchronous fabric (AF) among the tiles. This specific structure may be specific to the coarse-grained reconfigurable array (CGRA) to be used in the execution of the program and therefore is not reflected in the assembly language program. On the other hand, an assembly language program is not affected by such details and therefore may be mapped for execution on a different coarse-grained reconfigurable array (CGRA) having different structural details.
[0028] The scheduler may map instructions of an assembly language program for execution in a tile of a coarse-grained reconfigurable array (CGRA). Since each tile may have a pipeline time-multiplexed processing unit, a new instruction may be started on each tile at each clock cycle. Therefore, the scheduler may generate a schedule that specifies which instruction is programmed on which tile for execution at which clock cycle. The scheduler may determine the tiles and clock cycles of the mapped instructions in the correct combination so that the data flow in the coarse-grained reconfigurable array (CGRA) propagates in the proper timing. For example, the output of the tile is generated at the proper clock cycle so as to be provided as input in time through a synchronous fabric (SF) and / or an asynchronous fabric (AF) for further processing in the tile. When instructions are mapped to tiles, memory variables used by the instructions are also mapped to the memory in the tile.
[0029] Based on the schedule for instructions executed in the tile, a software tool (e.g., a downgrade program) may be configured to generate an execution configuration of a coarse-grained reconfigurable array for running an assembly language program. The software tool may determine the details of how each connection between tiles is configured. The software tool may determine the low-level details of partitioning the tile memory into regions to implement the memory variables mapped to the tile. The software tool may determine the setting of the correct multiplexer bits in the tile to ensure that data flows correctly within the tile at the correct clock cycle. Even if there is one missing bit, the entire program may be interrupted / corrupted. The details determined by the software tool may be specified in the execution configuration to control the execution of the assembly language program in the coarse-grained reconfigurable array (CGRA).
[0030] For example, based on an assembly language program and a timeline, a software tool can traverse a data flow graph to track which operations will be the masters of subsequent operations. As the software tool traces the graph, it can set outgoing controls for the current tile operation; and as the software tool traverses to a child level, it can set incoming control information on the cycle it arrives at. Control settings can also be determined and set for data passing through tiles and routes used on delay registers.
[0031] The software tools may also use the dispatch interface information and memory interface information provided in the assembly language program to configure the operation of the dispatch interface and memory interface of the coarse-grained reconfigurable array (CGRA). The assembly language program specifies high-level details about the messaging generated by the dispatch interface and memory interface. Using the schedule, the software tools may identify messaging according to physical hardware locations in the coarse-grained reconfigurable array (CGRA).
[0032] Software tools have various advantages. Manually generating execution configurations for coarse-grained reconfigurable arrays (CGRAs) is a tedious, laborious, error-prone process that can take tens of man-hours even for simple problems. Software tools automate the work to allow easy verification of hardware constraints. If hardware timing details change, the software tool can be rerun with parameter changes to generate a new execution configuration. The design of this software tool, which is configured to receive a schedule generated by a scheduler as input, allows many hardware details to be offloaded from the scheduler so that implementations of different mapping strategies for the scheduler can focus on instruction placement.
[0033] Figure 1 The structure of an assembly language program for execution in a coarse-grained reconfigurable array according to one embodiment is described.
[0034] exist Figure 1 In the example, the assembly language program 101 is configured with dispatch interface information 111 , memory interface information 113 , tile memory information 115 , and flow description 117 .
[0035] The dispatch interface information 111 identifies memory variables to accept arguments to be passed as input to the assembly language program 101 and the data properties of the arguments. The dispatch interface information 111 may further specify the data properties of the return value of the assembly language program 101. The dispatch interface information 111 may be used to configure a dispatch interface of a coarse-grained reconfigurable array (CGRA) 103 for implementing the assembly language program 101. To execute the assembly language program 101, the memory variables identified in the dispatch interface information 111 are mapped to tile memories in the coarse-grained reconfigurable array (CGRA) 103. Thus, the dispatch interface information 111 specifies the operation of the dispatch interface to store input data to the memory location represented by the memory variable.
[0036] The memory interface information 113 identifies memory access operations performed in the flow description 117 to access tile memories in the coarse-grained reconfigurable array (CGRA) 103. The memory access operations may include operations to store data in memory variables used in the flow description 117, and operations to read data from memory variables used in the flow description 117. In order to execute the assembly language program 101, the memory variables identified in the memory interface information are mapped to tile memories in the coarse-grained reconfigurable array (CGRA) 103.
[0037] The tile memory information 115 identifies memory variables used in the flow description 117 and accesses properties of the memory variables. Such memory variables may include memory variables identified in the dispatch interface information 111 to store arguments or inputs to the assembly language program 101, memory variables identified in the memory interface information 113, and other memory variables that may be used in synchronization operations of data flows in the flow description 117.
[0038] The flow description 117 specifies one or more data flow graphs. Each data flow graph identifies the synchronous data flow through the memory variables mapped to the tile memory and the synchronous values mapped to the connections between the tiles; and each data flow graph further identifies the calculations (e.g., addition, multiplication, bitwise shift, etc.) performed on those values on the tile data path. For example, some memory variables may be identified in the dispatch interface information 111, the memory interface information 113, the tile memory information 115 for synchronous use (e.g., FIFO) or asynchronous use (e.g., dispatch / memory interface) of the tile memory, and therefore for mapping to the tile memory in an implementation; additional variables that may or may not be mapped to the tile memory in an implementation may be used in the flow description 117. For example, synchronization values used through FIFOs in the flow description 117 are mapped to tile memory; some variables in the flow description 117 may be mapped to tile memory using FIFOs to meet timing requirements in scheduled instructions for execution on tiles of the coarse-grained reconfigurable array (CGRA) 103; and some variables in the flow description 117 may not necessarily be mapped to tile memory. The data flow graph may include identification of memory access operations specified in the memory interface information 113. The memory access operations specified in the memory interface information 113 are implemented via communications over an asynchronous fabric (AF) in the coarse-grained reconfigurable array (CGRA) 103. In one embodiment, the flow description 117 may have multiple sections, each specifying a data flow. Each data flow may optionally include identification of a set of asynchronous variables specified in the dispatch interface information 111, the memory interface information 113, and the tile memory information 115. Instructions of the data flow may begin execution upon receiving a message indicating that data identified by the set of asynchronous variables are ready. Each data stream may be programmed to send asynchronous messages to another data stream (e.g., to start executing a loop, continue a stream, send a data value, etc.). Each data stream may stop outputting results to one or more instructions in the asynchronous variables specified in the dispatch interface information 111, the memory interface information 113, and the tile memory information 115. New identification of data / variables may be used in each data stream to represent data generated within the data stream. Such new variables used within each data stream are transient because the data represented by the variables are consumed within the data stream and are discarded after the data stream is executed. Therefore, asynchronous variables / data in program 101 refer to data stored in a location / variable for use at an unspecified / unknown time when the data is needed; and there is no hardware-imposed limit on the time period between the arrival of the data and the use of the data; in contrast, synchronous variables / data refer to data generated for use at a time determined by the synchronous connection in the coarse-grained reconfigurable array (CGRA) 103. Instructions in a data stream may not be connected based on the sequence of instructions written in the stream description. Some instructions are related to each other based on data being consumed as input and data being produced as output, which data may be consumed synchronously or propagated asynchronously.
[0039] Combined with the following Figures 3 to 6 Further details are provided regarding the coarse-grained reconfigurable array 103 , the dispatch interface information 111 , the memory interface information 113 , and the tile memory information 115 .
[0040] Figure 2 Description According to one embodiment, an assembly language program is generated using a compiler.
[0041] exist Figure 2 In the embodiment of the present invention, a user may use a high-level language to specify a program 105 of operations to be performed by the coarse-grained reconfigurable array 103. A compiler 107 may read the high-level language program 105 and convert it into Figure 1 Assembly Language Programming 101.
[0042] Alternatively, a user may write assembly language program 101 without using a compiler (eg, 107). For example, a programming / compilation tool may be adapted to receive user input to specify assembly language program 101.
[0043] Figure 3 A coarse-grained reconfigurable array is described in which an assembly language program according to one embodiment may be configured to specify operations.
[0044] For example, you can implement Figure 1 Assembly language program 101 for Figure 3 The coarse-grained reconfigurable array 103 is implemented.
[0045] exist Figure 3 In FIG. 1 , the coarse-grained reconfigurable array 103 has a plurality of tiles 141 , 143 , . . . , 145 that can operate in parallel. The tiles may have the same (or similar) structure.
[0046] A typical tile 141 includes tile memories 131, ..., 133 having a synchronous connection 135 with a computation logic 137. The computation logic 137 may be configurable to execute different instructions. For example, the computation logic 137 may include a single instruction multiple data (SIMD) unit. Upon receiving a single instruction, the single instruction multiple data (SIMD) unit may operate on multiple data items in the tile memories 131, ..., 133. For example, the computation logic 137 may include a pipeline time multiplexing processing unit that may start executing a new instruction at each clock cycle. The execution of the instruction may be completed after a predetermined number of clock cycles. The result of executing the instruction may be propagated from one tile (e.g., 141) to an adjacent tile (e.g., 143) via a synchronous connection 129 within a predetermined number of clock cycles. The result of executing the instruction may also be accessed through a memory interface (e.g., 123, ..., 125 and a dispatch interface 121) via an asynchronous connection 127.
[0047] The coarse-grained reconfigurable array 103 has synchronization connections 129 among some pairs of tiles 141, 143, ..., 145. For example, the synchronization connection 129 provides a direct connection between tile 141 and tile 143, but does not provide a direct connection between tile 143 and tile 145. For example, the synchronization connection 129 can connect adjacent tiles (e.g., 141, 143) to form a chain or pipeline among the tiles 141, 143, ..., 145.
[0048] The coarse-grained reconfigurable array 103 has an asynchronous connection 127 between the tiles 141, 143, ..., 145 and the memory interfaces 123, ..., 125 and the dispatch interface 121. The dispatch interface 121 can act as a memory interface. Each memory interface (e.g., 123 or dispatch interface 121) can access the tile memory of one or more tiles through the asynchronous connection 127. Each of the tiles 141, 143, ..., 145 can have a delay register that can be controlled to provide the output of the tile to synchronize with the timing of executing the next instruction that uses the output. The dispatch interface 121 can communicate the input and output of the coarse-grained reconfigurable array 103 to and from circuits outside the coarse-grained reconfigurable array 103.
[0049] Figure 1 The assembly language program 101 can be written without information / details of the specific structure of the coarse-grained reconfigurable array 103, such as the number of tiles in the coarse-grained reconfigurable array 103, the availability of specific synchronous connections 129 among certain pairs of tiles 141, 143, ..., 145, the availability of asynchronous connections 127 between specific memory interfaces (e.g., 123) and specific tiles (e.g., 143), etc.
[0050] In the case of coarse-grained reconfigurable array 103, it is possible to map Figure 1 The assembly language program 101 of the coarse-grained reconfigurable array 103 can be executed using tiles 141, 143, ..., 145. The dispatch interface information 111, the memory interface information 113, and the tile memory information 115 can assist in mapping; and the flow description 117 makes it easier to identify the correct schedule for mapping each instruction to the corresponding tile at the correct clock cycle, so that the coarse-grained reconfigurable array 103 correctly executes the operation of the assembly language program 101.
[0051] The operation of the coarse-grained reconfigurable array 103 may be described and / or scheduled as data flow among tile memories (e.g., 131, ..., 133) of tiles (e.g., 141, 143, ..., 145) at various clock cycles through connections 135, 129, and 127 and computation logic 137. Since the flow description 117 describes the data flow required for the operation of the assembly language program 101, the data flow identified by the flow description 117 may be mapped to the data flow in the coarse-grained reconfigurable array 103 for execution.
[0052] Figure 4 Dispatching interface information of an assembly language program according to one embodiment is described.
[0053] For example, Figure 4 The dispatch interface information 111 can be used to Figure 1 In the assembly language program 101.
[0054] Figure 1 The assembly language program 101 may have a plurality of arguments 151, ..., 161 to receive inputs of the assembly language program 101. For each of the arguments 151, ..., 161, the dispatch interface information 111 identifies a memory variable (e.g., 153 or 163) to be mapped into the tile memory (e.g., 131 or 133) and a memory property (e.g., 155 or 165) of the corresponding memory variable (e.g., 153 or 163) (e.g., the property of input data to be received via the corresponding argument). The memory property (e.g., 155 or 165) may identify the data type and / or data size of the input to be received via the corresponding argument (e.g., 151 or 161).
[0055] Storing the input data to the memory locations represented by the memory variables 153 , . . . , 163 may be implemented via operations of the dispatch interface 121 of the coarse-grained reconfigurable array 103 .
[0056] Dispatch interface information 111 may further specify return value properties 159 of assembly language program 101. For example, return value properties 159 may specify a data type and / or data size of a value to be returned by assembly language program 101 when execution of assembly language program 101 is complete.
[0057] Figure 5 Memory interface information of an assembly language program according to one embodiment is described.
[0058] For example, Figure 5 The memory interface information 113 can be used to Figure 1 In the assembly language program 101.
[0059] The memory interface information 113 identifies a plurality of memory access operations 173, ..., 183. Each memory access operation (e.g., 173 or 183) may be an operation to store data in a memory or read data from a memory, wherein a memory location is represented by a memory variable (e.g., 175 or 185) having a corresponding memory property (e.g., 177 or 187) for the data stored or accessed at the memory location. The memory access operation (e.g., 173 or 183) may be implemented via operations of the memory interfaces 123, ..., 125 and / or the dispatch interface 121 of the coarse-grained reconfigurable array 103.
[0060] The memory access operation (e.g., 173 or 183) is associated with the access ID (e.g., 171 or 181) in the memory interface information 113 to indicate the corresponding memory access operation (e.g., 173 or 183). The flow description 117 of the assembly language program 101 may use the access ID (e.g., 171 or 181) to specify the use of the corresponding memory access operation (e.g., 173 or 183) in the data flow graph.
[0061] The memory property (eg, 177 or 187 ) may identify the data type and / or data size of the data to be operated on via the memory access operation (eg, 173 or 183 ).
[0062] Figure 6 The block memory information of an assembly language program according to one embodiment is described.
[0063] For example, Figure 6 The tile memory information 115 can be used to Figure 1 In the assembly language program 101.
[0064] The tile memory information 115 identifies properties (e.g., 157, ..., 167, 179, ..., 189, 193, ...) of corresponding memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) used in the flow description 117 to identify memory locations in tiles of the coarse-grained reconfigurable array 103. To execute the assembly language program 101, the memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) are mapped to tile memories (e.g., 131, ..., 133) of tiles (e.g., 141, 143, ..., 145) of the coarse-grained reconfigurable array 103.
[0065] The properties (e.g., 157, ..., 167, 179, ..., 189, 193, ...) may identify the memory access type, size, etc. of the corresponding memory variable (e.g., 153, ..., 163, 175, ..., 185, 191, ...). Examples of memory access types may include unknown, shared, first-in-first-out (FIFO), etc.
[0066] The memory variables specified in the tile memory information 115 may include memory variables identified in the dispatch interface information 111 (e.g., 153, ..., 163), memory variables identified in the memory interface information 113 (e.g., 175, ..., 185), and other memory variables used to identify memory locations of data flows in the flow description 117. The flow description 117 further identifies operations performed to transform data along the flow.
[0067] Figure 7 A method of specifying operations in a coarse-grained reconfigurable array according to one embodiment is presented.
[0068] For example, Figure 7 The method may be implemented by software and / or hardware in a computing device to generate Figure 1 The assembly language program 101 is executed by a user, a compiler or a compiling / programming tool.
[0069] At block 201 , a user, compiler, and / or compiling / programming tool identifies dispatch interface information 111 representing operations to be performed via a dispatch interface 121 of a coarse-grained reconfigurable array 103 to receive input.
[0070] For example, the coarse-grained reconfigurable array 103 may have a plurality of tiles 141, 143, ..., 145 interconnected via synchronous connections 129 and 135 and asynchronous connection 127. Each of the tiles (e.g., 141) has a tile memory (e.g., 131, ..., 133) and reconfigurable computation logic (e.g., 137). In response to an instruction, the computation logic 137 may be reconfigured to perform the operation of the instruction in a data flow from one memory location to another memory location in the coarse-grained reconfigurable array 103.
[0071] For example, the dispatch interface information 111 may include identification of first memory variables 153, ..., 163 for arguments 161, ..., 161, respectively, to indicate an operation of writing input to the memory location represented by the first memory variables 153, ..., 163 according to the arguments.
[0072] At block 203, a user, compiler, and / or compiling / programming tool identifies memory interface information 113 representing operations to be performed via one or more memory interfaces of a coarse-grained reconfigurable array.
[0073] For example, the memory interface information 113 may include identification of second memory variables 175, ..., 185 associated with memory access operations 173, ..., 183 for storing or retrieving data items to or from memory locations referenced and represented by the second memory variables 175, ..., 185.
[0074] Memory interface information 113 and dispatch interface information 111 may include the type and size of data items identified by memory variables (e.g., 153, 163, 175, 185) and operated in corresponding memory access operations (e.g., 173, 183, or storing input according to arguments 151, ..., 161).
[0075] At box 205, a user, compiler and / or compilation / programming tool identifies tile memory information 115, which is about a set of memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) that reference memory locations to be implemented in a tile memory (e.g., 131, 133) of the coarse-grained reconfigurable array 103.
[0076] The tile memory information 115 may further identify the access type and size of the set of memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) for implementation in the coarse-grained reconfigurable array. The set of memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) may include a first memory variable (e.g., 153, ..., 163) identified in the dispatch interface information 111, a second memory variable (e.g., 175, ..., 185) identified in the memory interface information 113, and at least one third memory variable 191 that references a memory location in one or more synchronous data streams to be implemented via the coarse-grained reconfigurable array 103.
[0077] At block 207, a user, compiler, and / or compile / programming tool identifies one or more simultaneous data flows through memory locations referenced via memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) in the tile memory information 115 to produce results from the inputs. The data may be transformed by executing instructions along the flows; and the data flows may pass through other variables that are not necessarily mapped to tile memory.
[0078] At block 209, a user, compiler, and / or compiling / programming tool generates an assembly language program 101 containing dispatch interface information 111, memory interface information 113, tile memory information 115, and a flow description 117 specifying one or more data flows.
[0079] For example, compiler 107 may be configured to compile computer program 105 written in a high-level language to generate assembly language program 101 .
[0080] Alternatively, the compile / programming tool may be configured to present a user interface to receive user input to identify dispatch interface information 111 , memory interface information 113 , tile memory information 115 , and one or more data flows, etc. Based on the user input, the compile / programming tool may check for errors and generate the assembly language program 101 .
[0081] Optionally, the compiler and / or compilation / programming tool may be further configured to map one or more data flows specified in the assembly language program 101 to data flows in the coarse-grained reconfigurable array 103, including mapping the set of memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) to tile memories (e.g., 131, 133) in the coarse-grained reconfigurable array 103.
[0082] Figure 8 An instruction execution schedule generated from an assembly language program according to one embodiment is described.
[0083] For example, from Figure 1 The assembly language program 101 generates an instruction execution schedule 223 for use in Figure 3 The coarse-grained reconfigurable array 103 is executed using a scheduler 221 implemented as a software tool.
[0084] Figure 1 An assembly language program 101 specifies a data flow through storage locations represented by memory variables. The data flow has instructions that specify operations to be performed on the data in the flow.
[0085] The hardware configuration file 239 may identify high-level structural features of the coarse-grained reconfigurable array 103 to be used to run the assembly language program 101. Such high-level structural features may be specified for the coarse-grained reconfigurable array 103 among possible implementations of the coarse-grained reconfigurable array. For example, the high-level structural features may specify the number of tiles (141, 143, ..., 145) in the coarse-grained reconfigurable array 103, the number of memory interfaces (e.g., 123, ..., 125), the connection topology in the synchronous and asynchronous connections 127, the number of clock cycle delays in the synchronous and asynchronous connections 127, etc.
[0086] Hardware profile 239 has sufficient detail to allow the scheduler to map instructions (e.g., 233, 243) in the data stream of assembly language program 101 into tiles 141, 143, ..., 145 for execution at the appropriate times indicated by the identification of cycles (e.g., 231, 241).
[0087] To achieve optimal performance, the scheduler 221 may map instructions to different tiles 141, 143, ..., 145 for execution. Although all instructions of the assembly language program 101 may be mapped to a single tile (e.g., 143 or 141) for execution, such a schedule is inefficient in that it fails to utilize resources in the remaining tiles (e.g., 145). The scheduler 221 is configured to distribute instructions to different tiles 141, 143, ..., 145 for parallel execution to improve performance and reduce or minimize the number of clock cycles to complete the computation of the assembly language program 101.
[0088] For example, the scheduler 221 may assign instructions of different data streams to different tiles. For example, the scheduler 221 may attempt to place the next instruction to be placed in different tiles and identify the placement that results in the best performance for executing to the next instruction.
[0089] When placing instructions (eg, 233, ..., 243), scheduler 221 also identifies clock cycles (eg, 231, ..., 241) for initiating execution of instructions (eg, 233, ..., 243) in tiles (eg, 141, 143, ..., 145).
[0090] In general, the instruction execution schedule 223 may include an instruction placement sequence for each of the tiles 141, 143, ..., 145. For example, a typical tile 141 is assigned to execute instructions 233, ..., 243 at clock cycles 231, ..., 241, respectively. The scheduler 221 identifies the cycles 231, ..., 241 so that the output of the computation can be used as input for subsequent computations in the correct cycle. Thus, data can flow in and among the tiles 141, 143, ..., 145 for synchronous operations.
[0091] In addition, the hardware configuration file 239 allows the scheduler 221 to map memory variables in the assembly language program 101 to the tiles 141, 143, ..., 145 for implementation via the tile memory (e.g., 131, ..., 133), such as Fig. 9 As described in .
[0092] Fig. 9 A memory map for implementing an assembly language program in a coarse-grained reconfigurable array according to one embodiment is described.
[0093] exist Fig. 9 In the example, scheduler 221 identifies a memory map 225 for assembly language program 101 for coarse-grained reconfigurable array 103 having the structural features identified in hardware configuration file 239 .
[0094] For example, in a typical tile 141, memory variables 153, ..., 175 of the assembly language program 101 are mapped in the memory map 225 for implementation via tile memory 131, ..., 133 of the tile 141. Other memory variables of the assembly language program 101 are mapped to other tiles (e.g., 143, ..., 145).
[0095] When data stored in a variable (e.g., 153) is mapped to a tile (e.g., 141) for execution using its tile memory (e.g., 131 or 133), it is often efficient to map instructions that operate on the data to the same tile (e.g., 141) because accessing data via connections between tiles may take longer than accessing data within the tile. Therefore, the generation of the memory map 225 and the generation of the instruction execution schedule 223 may be performed together to identify the high-performance schedule 223.
[0096] Certain hardware details may be excluded from the hardware configuration file 239 to allow the scheduler 221 to focus on the instruction placement operations in the tiles 141, 143, ..., 145. Thus, the scheduler 223 does not determine the low-level details of configuring the coarse-grained reconfigurable array 103 to run the assembly language program 101 according to the schedule 223. Such low-level details may include how the dispatch interface 121 and the memory interfaces 123, ..., 125 are configured for operation of the assembly language program 101, how the memory locations represented by the memory variables (e.g., 153, 175) are implemented via the tile memory (e.g., 131, 133), how the connections (e.g., 135) in the tile (e.g., 141) are configured to facilitate the correct data flow within the tile (e.g., 141, 143, ..., 145), etc. A more detailed hardware configuration file may be used to generate a configuration for executing the assembly language program 101, such as Fig.10 As described in .
[0097] Fig.10 An execution configuration of a coarse-grained reconfigurable array for running an assembly language program according to one embodiment is described.
[0098] exist Fig.10 In the embodiment of the present invention, the hardware configuration file 249 can specify the low-level details of the coarse-grained reconfigurable array 103. The low-level details can no longer be determined by Figure 8 and Fig. 9 The hardware profile 239 used by the scheduler 221.
[0099] Configuration generator 229 may use hardware configuration file 249 to determine execution configuration 227 of assembly language program 101 having memory map 225 and instruction execution schedule 223 .
[0100] Execution configuration 227 has detailed information on how to control and / or use elements of coarse-grained reconfigurable array 103 to run assembly language program 101 .
[0101] For example, the memory map 225 specifies which tile (e.g., 141) of the coarse-grained reconfigurable array 103 is used to implement the memory represented by the memory variable (e.g., 153). The configuration generator 229 may further determine which portion of the tile memory (e.g., 131) in the tile (e.g., 141) is used for the memory represented by the memory variable (e.g., 153) for executing the configuration 227.
[0102] For example, the instruction execution schedule 223 identifies which instruction (e.g., 233) is scheduled to be initiated for execution on which tile (e.g., 141) at which clock cycle (e.g., 231). The configuration generator 229 may further determine the connectivity control 236 for the configuration of the connection 135 in the tile (e.g., 141) to ensure the proper data flow in the tile (e.g., 141) for executing the instruction. For example, the connection 135 in the tile (e.g., 141) may be configured via a control bit for a multiplexer in the connection 135; and the connectivity control 236 may identify the control bit.
[0103] For example, the dispatch interface information 111 of the assembly language program 101 specifies how the dispatch interface 121 stores inputs received as arguments 151, ..., 161. After determining how to use which slice memory (e.g., 131, ..., 133) of which slices (e.g., 141, 143, ..., 145) to implement the memory variables 153, ..., 163 associated with the arguments 151, ..., 161, the configuration generator 229 may further determine the operation control 237 of the dispatch interface 121 to process the inputs.
[0104] Similarly, after determining the tile memory implementation for the memory variables 175, ..., 185 identified in the memory interface information 113 of the assembly language program 101, the configuration generator 229 may further determine the operation control (e.g., 247) of the memory interface (e.g., 123, ..., 125) to process the memory access operations 173, ..., 183 identified in the processing flow description 117 using its access ID 171, ..., 181.
[0105] For example, the configuration generator 229 may trace the data flow specified in the flow description 117 of the assembly language program 101 and implement it according to the instruction execution schedule 223. When the trace detects that data flows into a tile (e.g., 141) at clock cycle 231, the configuration generator 229 identifies an incoming control 235 to be applied to facilitate the flow of data into the tile 141; and when the trace detects that data flows out of the tile 141 at clock cycle 241, the configuration generator 229 identifies an outgoing control 245 to be applied to the tile 141 to facilitate the flow of data out of the tile 141 (e.g., a timing control of a delay register of the tile 141).
[0106] When the coarse-grained reconfigurable array 103 is controlled and / or used according to the execution configuration 227 , the coarse-grained reconfigurable array 103 may execute instructions of the assembly language program 101 according to the instruction execution schedule 223 to perform calculations as specified in the assembly language program 101 .
[0107] Fig.11 A method for identifying a configuration of a coarse-grained reconfigurable array to run an assembly language program is presented according to one embodiment.
[0108] For example, Fig.11 The method can be used in the configuration generator 229 implemented as a downgrade program to generate Fig.10 Execution configuration 227.
[0109] At box 251, the configuration generator 229 receives the assembly language program 101, which identifies a data flow through memory locations represented by memory variables (e.g., 153, ..., 163, 175, ..., 185, 191, ...) and identifies instructions configured to transform data in the data flow (e.g., as specified in the flow description 117).
[0110] At block 253, configuration generator 229 further receives hardware configuration file 249 that identifies details of coarse-grained reconfigurable array 103 having a plurality of tiles 141, 143, ..., 145 that are operable in parallel.
[0111] For example, the coarse-grained reconfigurable array 103 may include a plurality of memory interfaces (e.g., 123). One of the memory interfaces may be configured / used as a dispatch interface 121. The coarse-grained reconfigurable array 103 has a plurality of tiles 141, 143, ..., 145 interconnected via synchronous connections 127 and asynchronous connections 129. Each of the tiles may have a tile memory (e.g., 131, ..., 133) and a reconfigurable computing logic 137.
[0112] At block 255 , configuration generator 229 further receives instruction execution schedule 223 , which identifies the timing of executing instructions of assembly language program 101 in tiles 141 , 143 , . . . , 145 .
[0113] At box 257, the configuration generator 229 identifies memory (e.g., 131, ..., 133) in the tile (e.g., 141, 143, ..., 145) that is configured to implement the memory location represented by the memory variable (e.g., 153, ..., 163, 175, ..., 185, 191, ...).
[0114] At block 259 , configuration generator 229 generates execution configuration 227 that identifies operational controls (eg, 235 , 245 , 236 , 237 , 247 ) to be applied in coarse-grained reconfigurable array 103 during execution of instructions of assembly language program 101 .
[0115] For example, the assembly language program 101 includes dispatch interface information 111 representing an operation executed to store an input into a first memory location represented by a first memory variable (153, ..., 163). After identifying a tile memory to implement the first memory location, the configuration generator 229 may identify an operation control 237 of the dispatch interface 121 of the coarse-grained reconfigurable array 103 based on the dispatch interface information 111 to store the input into the tile memory identified to implement the first memory location.
[0116] For example, the assembly language program 101 includes memory interface information 113 representing an operation executed to store data at or retrieve data from a second memory location represented by a second memory variable (175, ..., 185). After identifying a tile memory used to implement the second memory location, the configuration generator 229 can identify an operation control 247 of a memory interface (e.g., 123 or 125) of the coarse-grained reconfigurable array 103 based on the memory interface information 113 to store data at or retrieve data from the tile memory identified to implement the second memory location.
[0117] For example, assembly language program 101 has a flow description 117 that specifies data flow. Configuration generator 229 can track data flow in conjunction with identifying the timing of executing instructions to identify the timing of controls (e.g., 235, 245, 236, 237, 247) to be applied in the slice during execution of assembly language program 101.
[0118] For example, during tracing of data flow, the configuration generator 229 can detect an instance of data flowing into a first tile (e.g., 141) of the coarse-grained reconfigurable array 103. In response, the configuration generator 229 can identify incoming controls 235 and the timing (e.g., cycles 231) of the incoming controls 235 to be applied to the first tile 141 during execution of the assembly language program 101 in the coarse-grained reconfigurable array 103.
[0119] For example, during tracing of data flow, the configuration generator 229 can detect an instance of data flowing out of the first tile 141 of the coarse-grained reconfigurable array 103. In response, the configuration generator 229 can identify outgoing controls 245 and the timing (e.g., cycles 241) of the outgoing controls to be applied to the first tile 141 during execution of the assembly language program 101 in the coarse-grained reconfigurable array 103.
[0120] For example, during tracking of data flow using tiles, the configuration generator 229 may identify connectivity controls 236 of tiles 141, 143, ..., 145 for data to flow within the tiles according to the instruction execution schedule 223. For example, each respective tile (e.g., 141) among the tiles has internal connections 135 between tile memories 131, ..., 133 and computation logic 137. After determining the tile memories implementing memory variables in the assembly language program 101, the configuration generator 229 may determine connectivity among the tile memories (e.g., 131, ..., 133) and computation logic 137 to facilitate data flow within the tile (e.g., 141). The internal connections 135 may include multiplexers to control data paths; and the connectivity controls 236 may include setting bits to control the multiplexers to implement data flow.
[0121] After determining execution configuration 227, coarse-grained reconfigurable array 103 may be controlled according to the contents of execution configuration 227 during execution of instructions of assembly language program 101 according to instruction execution schedule 223. Use of execution configuration 227 ensures the correct operating configuration for running assembly language program 101. Different schedules (e.g., 223) of assembly language program 101 as input to configuration generator 229 may result in different configurations (e.g., 227).
[0122] Fig.12 An example machine of a computer system is illustrated within which a set of instructions may be executed for causing the machine to perform any one or more of the methodologies discussed herein.
[0123] Fig.12The computer system may be used to perform the operations of the configuration generator 303 to generate an execution configuration 227 to run the reference program on the coarse-grained reconfigurable array (CGRA) 103 by executing instructions configured to perform the operations corresponding to the configuration generator 229. Figures 1 to 11 An assembly language program 101 is discussed.
[0124] In some embodiments, the machine may be connected (e.g., using a network) to other machines in a Local Area Network (LAN), an Intranet, an Extranet, and / or the Internet. The machine may operate in the capacity of a server or a client user machine in a client-server network environment, as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or a client user machine in a cloud computing infrastructure or environment.
[0125] For example, the machine may be configured as a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a network appliance, a server, a network router, a switch or a bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Furthermore, while a single machine is described, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.
[0126] Fig.12 The example computer system illustrated in includes a processing device 302, a main memory 304, and a data storage system 318 that communicate with each other via a bus 330. For example, the processing device 302 may include one or more microprocessors; the main memory may include a read-only memory (ROM), a flash memory, a dynamic random access memory (DRAM) (such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM)), a static random access memory (SRAM), etc. The bus 330 may include, or be replaced by, multiple buses.
[0127] Fig.12 The processing device 302 in illustrative embodiments represents one or more general-purpose processing devices, such as a microprocessor, a central processing unit, or the like. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor that implements other instruction sets, or a processor that implements a combination of instruction sets. The processing device 302 may also be one or more special-purpose processing devices, such as an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like.
[0128] Fig.12The computer system may further include a network interface device 308 for communicating via a computer network 320 .
[0129] The data storage system 318 may include a machine-readable medium 324 (also referred to as a computer-readable medium) having stored thereon one or more sets of instructions 326 or software embodying any one or more of the methodologies or functionality described herein. The instructions 326 may also reside, completely or at least partially, within the main memory 304 and / or the processing device 302 during execution by the computer system, the main memory 304 and the processing device 302 also constituting machine-readable storage media.
[0130] In one embodiment, the instructions 326 include instructions for implementing the configuration generator 303 (eg, referring to Figures 1 to 11 The machine-readable medium 324 is shown as a single medium in the example embodiment, but the term "machine-readable storage medium" should be considered to include a single medium or multiple media storing one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for machine execution and causing the machine to perform any one or more methodologies of the present disclosure. Therefore, the term "machine-readable storage medium" should be considered to include, but not limited to, solid-state memory, optical media, and magnetic media.
[0131] The present disclosure includes the methods described above and apparatuses that perform the methods, including data processing systems that perform these methods and computer-readable media containing instructions that, when executed on a data processing system, cause the system to perform these methods.
[0132] A typical data processing system may include an interconnect (eg, a bus and system core logic) that interconnects microprocessor(s) and memory. A microprocessor is typically coupled to a cache memory.
[0133] The interconnect interconnects the microprocessor(s) and memory together and also interconnects them to I / O device(s) via input / output controller(s). The I / O devices may include display devices and / or peripheral devices such as a mouse, keyboard, modem, network interface, printer, scanner, camera, and other devices known in the art. In one embodiment, when the data processing system is a server system, some I / O devices such as a printer, scanner, mouse, and / or keyboard are optional.
[0134] The interconnect may include one or more buses connected to each other through various bridges, controllers, and / or adapters. In one embodiment, the I / O controller includes a USB adapter for controlling USB (Universal Serial Bus) peripheral devices, and / or an IEEE-2394 bus adapter for controlling IEEE-2394 peripheral devices.
[0135] The memory may include one or more of: ROM (read only memory), volatile RAM (random access memory), and non-volatile memory such as a hard drive, flash memory, and the like.
[0136] Volatile RAM is typically implemented as dynamic RAM (DRAM), which continuously requires power in order to refresh or maintain the data in the memory. Nonvolatile memory is typically a magnetic hard drive, magneto-optical drive, optical drive (e.g., DVDRAM), or other types of memory systems that maintain data even after power is removed from the system. Nonvolatile memory can also be random access memory.
[0137] The non-volatile memory may be a local device directly coupled to the rest of the components in the data processing system. Non-volatile memory that is remote from the system may also be used, such as a network storage device coupled to the data processing system through a network interface (such as a modem or Ethernet interface).
[0138] In the present disclosure, in order to simplify the description, some functions and operations are described as being performed or caused by software codes. However, such expressions are also used to specify functions resulting from the execution of codes / instructions by a processor (eg, a microprocessor).
[0139] Alternatively or in combination, the functions and operations as described herein may be implemented using dedicated circuitry, such as using an application specific integrated circuit (ASIC) or a field programmable gate array (FPGA), with or without software instructions. Embodiments may be implemented using hardwired circuitry, either without software instructions or in combination with software instructions. Thus, the techniques are not limited to any specific combination of hardware circuitry and software, nor to any particular source for the instructions executed by a data processing system.
[0140] While one embodiment may be implemented on fully functional computers and computer systems, various embodiments are capable of being distributed as a computing product in a variety of forms and can be applied regardless of the specific type of machine or computer readable media used to actually implement the distribution.
[0141] At least some aspects disclosed may be embodied at least in part in software. That is, the techniques may be implemented in a computer system or other data processing system in response to its processor (e.g., microprocessor) executing sequences of instructions contained in a memory (e.g., ROM, volatile RAM, non-volatile memory, cache, or remote storage device).
[0142] The routines executed to implement the embodiments may be implemented as part of an operating system or a specific application, component, program, object, module or sequence of instructions (referred to as a "computer program"). A computer program is typically contained in various memories and storage devices that are located in the computer at different times and that, when read and executed by one or more processors in the computer, causes the computer to perform one or more instructions necessary to implement the elements involved in the various aspects.
[0143] Machine-readable media can be used to store software and data that cause the system to perform various methods when executed by a data processing system. Executable software and data can be stored in various places, including, for example, ROM, volatile RAM, non-volatile memory and / or cache. Parts of this software and / or data can be stored in any of these storage devices. In addition, data and instructions can be obtained from a centralized server or a peer-to-peer network. Different parts of data and instructions can be obtained from different centralized servers and / or peer-to-peer networks at different times and in different communication sessions or in the same communication session. Data and instructions can be obtained as a whole before executing the application. Alternatively, parts of data and instructions can be obtained dynamically and in a timely manner when execution is required. Therefore, it is not required that data and instructions be located as a whole on machine-readable media at a specific time.
[0144] Examples of computer-readable media include, but are not limited to, non-transitory, recordable and non-recordable media such as volatile and non-volatile memory devices, read-only memory (ROM), random access memory (RAM), flash memory devices, floppy disks and other removable disks, magnetic disk storage media, optical storage media (e.g., compact disk read-only memory (CDROM), digital versatile disks (DVD), etc.), etc. Computer-readable media may store instructions.
[0145] The instructions may also be embodied in digital and analog communication links using electrical, optical, acoustic or other forms of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.). However, propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.) are not tangible machine-readable media and are not configured to store instructions.
[0146] Generally speaking, a machine-readable medium includes any mechanism that provides (ie, stores and / or transmits) information in a form accessible by a machine (eg, a computer, a network device, a personal digital assistant, a manufacturing tool, any device with a set of one or more processors, etc.).
[0147] In various embodiments, hardwired circuitry may be used in combination with software instructions to implement the techniques. Thus, the techniques are not limited to any specific combination of hardware circuitry and software, nor to any specific source of instructions executed by a data processing system.
[0148] The above description and drawings are illustrative and should not be construed as limiting. Numerous specific details are described to provide a thorough understanding. However, in some instances, well-known or conventional details are not described in order to avoid obscuring the description. References to one or an embodiment in the present disclosure are not necessarily references to the same embodiment; and such references represent at least one.
[0149] In the foregoing specification, the present disclosure has been described with reference to specific exemplary embodiments thereof. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope as set forth in the appended claims. Accordingly, the specification and drawings should be regarded in an illustrative rather than a restrictive sense.
Claims
1. A method comprising: receiving an assembly language program that identifies a data flow through a memory location represented by a memory variable and identifies instructions configured to transform data in the data flow; receiving a hardware configuration file identifying details of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; receiving an instruction execution schedule, the instruction execution schedule identifying a timing for executing the instructions of the assembly language program in the slice; identifying a memory in the tile that is configured to implement the memory location represented by the memory variable; and An execution configuration is generated that identifies operational controls to be applied in the coarse-grained reconfigurable array during execution of the instructions of the assembly language program.
2. The method of claim 1 , wherein the coarse-grained reconfigurable array comprises a plurality of memory interfaces, one of the memory interfaces being configured as a dispatch interface; and the coarse-grained reconfigurable array further comprises the plurality of tiles interconnected via synchronous connections and asynchronous connections, each of the tiles having a tile memory and reconfigurable computing logic.
3. The method of claim 2, wherein the assembly language program includes dispatch interface information representing an operation executed to store an input into a first memory location represented by a first memory variable; and the method further comprising: An operational control of the dispatch interface of the coarse-grained reconfigurable array is identified based on the dispatch interface information to store the input to a tile memory identified to implement the first memory location.
4. The method of claim 3, wherein the assembly language program further includes memory interface information representing an operation performed to store data at or retrieve data from a second memory location represented by a second memory variable; and the method further comprising: An operational control of the memory interface of the coarse-grained reconfigurable array is identified based on the memory interface information to store data at or retrieve data from the tile memory identified to implement the second memory location.
5. The method of claim 4, wherein the assembly language program further comprises a flow description specifying the data flow; and the method further comprises: The data flow is traced using the identification of the timing of executing the instructions to identify the timing of control applied in the tile.
6. The method according to claim 5, further comprising: detecting data flowing into a first tile of the coarse-grained reconfigurable array during the tracking; and Incoming controls and timing of the incoming controls to be applied to the first tile during execution of the assembly language program in the coarse-grained reconfigurable array are identified based on the detection of data flowing into the first tile.
7. The method according to claim 5, further comprising: detecting data flowing out of a first tile of the coarse-grained reconfigurable array during the tracing; and Egress controls to be applied to the first tile and timing of the egress controls are identified based on the detection of data flowing out of the first tile.
8. The method according to claim 5, further comprising: Based on the tracing, identifying connectivity controls for the shard for data flowing within the shard according to the instruction execution schedule; wherein each respective one of the tiles has internal connections between tile memory and compute logic, the internal connections comprising a multiplexer to control a data path; and the connectivity control comprises a setting bit to control the multiplexer to implement the data flow; and Wherein the method further comprises: According to the execution configuration, the coarse-grained reconfigurable array is controlled during execution of the instructions of the assembly language program according to the instruction execution schedule.
9. A computing device, comprising: Memory; and a microprocessor coupled to the memory and configured to: receiving an assembly language program that identifies a data flow through a memory location represented by a memory variable and identifies instructions configured to transform data in the data flow; receiving a hardware configuration file identifying details of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; receiving an instruction execution schedule, the instruction execution schedule identifying a timing for executing the instructions of the assembly language program in the slice; identifying a memory in the tile that is configured to implement the memory location represented by the memory variable; and An execution configuration is generated that identifies operational controls to be applied in the coarse-grained reconfigurable array during execution of the instructions of the assembly language program.
10. The computing device of claim 9, wherein the coarse-grained reconfigurable array comprises a plurality of memory interfaces, one of the memory interfaces being configured as a dispatch interface; wherein the coarse-grained reconfigurable array further comprises the plurality of tiles interconnected via synchronous connections and asynchronous connections, each of the tiles having a tile memory and reconfigurable computing logic; and wherein the assembly language program further includes a flow description specifying the data flow; and the microprocessor is further configured to: tracing the data flow to identify the timing of control applied in the tile using the identification of the timing of executing the instructions; detecting first data flowing into a first tile of the coarse-grained reconfigurable array by tracking the data flow; identifying incoming controls and timing of the incoming controls to be applied to the first tile to facilitate the first data flow during execution of the assembly language program in the coarse-grained reconfigurable array; detecting second data flowing out of the first tile of the coarse-grained reconfigurable array by tracking the data flow; and Egress controls and timing of the egress controls to be applied to the first tile to facilitate the egress of the second data are identified.
11. The computing device of claim 10, wherein the assembly language program further includes memory interface information representing an operation performed to store data at or retrieve data from a second memory location represented by a second memory variable; and the microprocessor is further configured to: An operational control of the memory interface of the coarse-grained reconfigurable array is identified based on the memory interface information to store data at or retrieve data from the tile memory identified to implement the second memory location.
12. The computing device of claim 11, wherein the assembly language program includes dispatch interface information representing an operation executed to store an input into a first memory location represented by a first memory variable; and the microprocessor is further configured to: identifying, based on the dispatch interface information, an operational control of the dispatch interface of the coarse-grained reconfigurable array to store the input to a tile memory identified to implement the first memory location; and Based on the tracing, identifying connectivity controls for the shard for data flowing within the shard according to the instruction execution schedule; Each respective tile among the tiles has internal connections between tile memory and computation logic, the internal connections including multiplexers to control a data path; and the connectivity control includes a setting bit to control the multiplexers to implement the data flow.
13. A non-transitory computer storage medium storing instructions that, when executed by a computing device, cause the computing device to perform a method comprising: receiving an assembly language program identifying a data flow through memory locations represented by memory variables and identifying an opcode executable to transform data in the data flow; receiving a hardware configuration file identifying details of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; receiving an opcode execution schedule, the opcode execution schedule identifying a timing for executing the opcodes of the assembly language program in the slice; identifying a memory in the tile that is configured to implement the memory location represented by the memory variable; and generating an execution configuration that identifies operational controls to be applied in the coarse-grained reconfigurable array during execution of the opcodes of the assembly language program; Wherein according to the execution configuration, the coarse-grained reconfigurable array is controllable to execute the operation code of the assembly language program according to the operation code execution schedule to perform calculations of the assembly language program.
14. The non-transitory computer storage medium of claim 13, wherein the coarse-grained reconfigurable array comprises a plurality of memory interfaces, one of the memory interfaces being configured as a dispatch interface; and the coarse-grained reconfigurable array further comprises the plurality of tiles interconnected via synchronous and asynchronous connections, each of the tiles having a tile memory and reconfigurable computing logic; and Wherein the method further comprises: tracking the data flow to identify the timing of control applied in the tile using the identification of the timing of executing the opcode; detecting, during the tracking, first data flowing into a first tile of the coarse-grained reconfigurable array; identifying incoming controls and timing of the incoming controls to be applied to the first tile during execution of the assembly language program in the coarse-grained reconfigurable array based on the detection of the first data flowing into the first tile; detecting, during the tracing, second data flowing out of the first tile of the coarse-grained reconfigurable array; and Egress control to be applied to the first tile and timing of the egress control are identified based on the detection of the second data flowing out of the first tile.
15. The non-transitory computer storage medium of claim 14, wherein the method further comprises: identifying, based on dispatch interface information specified in the assembly language program to identify inputs to a first memory location, an operational control of the dispatch interface of the coarse-grained reconfigurable array to store the inputs to a tile memory identified to implement the first memory location; identifying, based on memory interface information specified in the assembly language program to identify a memory access operation at a second memory location, an operational control of the memory interface of the coarse-grained reconfigurable array to store data at or retrieve data from a tile memory identified to implement the second memory location; and Based on the trace, identifying connectivity controls for the tile for data flowing within the tile according to the opcode execution schedule; Each respective tile among the tiles has internal connections between tile memory and computation logic, the internal connections including multiplexers to control a data path; and the connectivity control includes a setting bit to control the multiplexers to implement the data flow.
Citation Information
Cited By
Coarse-grained reconfigurable array and hardware modeling generation method thereof
CN119940250A
A coarse-grained reconfigurable array and a hardware modeling generation method thereof
CN119940250B
