Scheduling instructions of program of data stream for execution in tile of coarseness reconfigurable array

Through the combination of the new assembly language and scheduler, the complexity of traditional compilation tools to schedule data flow programs in coarse-grained reconfigurable arrays is solved, efficient instruction execution and automated configuration are achieved, and the accuracy of data flow propagation is improved. efficiency.

CN118922818APending Publication Date: 2024-11-08MICRON TECHNOLOGY INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202380029366.9
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

Technical Problem

When traditional compilation tools run data flow programs in coarse-grained reconfigurable arrays, it is difficult to effectively schedule instructions to avoid synchronous flow corruption, and manual configuration is complex and laborious.

Method used

The data flow is described using the new assembly language, the program is mapped into pieces of coarse-grained reconfigurable arrays through parsers, and the scheduler is used to generate effective instruction execution schedules, automate configuration and scheduling processes, and reduce uninstallation of hardware details.

Benefits of technology

It improves the efficiency and accuracy of program scheduling, simplifies the configuration process, reduces the complexity and error rate of manual configuration, and achieves efficient data flow propagation.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN118922818A_ABST
    Figure CN118922818A_ABST
Patent Text Reader

Abstract

Instructions of a program are scheduled for execution on a coarseness reconfigurable array having a plurality of tiles capable of parallel operation. The program identifies a data stream passing a memory location represented by a memory variable and identifies instructions configured to transform data in the data stream. Based on a hardware profile identifying features of the coarseness reconfigurable array, a scheduler is configured to generate a memory image. The memory image identifies, for each respective memory variable in the program, one of the tiles that contains a memory location represented by the respective memory variable. Based on the memory image, a possible selection of brute force search is reduced, the scheduler assigns the instruction to the tile for execution, and determines a timing at which the instruction is executed in the tile.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Related Applications

[0002] This application claims priority to U.S. patent application Ser. No. 17 / 705,112, filed on Mar. 25, 2022, and entitled “Schedule Instructions of a Program of Data Flows for Execution in Tiles of a Coarse Grained Reconfigurable Array,” the entire disclosure of which is hereby incorporated by reference herein. Technical Field

[0003] At least some embodiments disclosed herein relate generally to scheduling instructions of a computer program for execution in a computing device and more particularly, but not limited to, scheduling instructions for parallel execution in multiple circuit tiles of a computing device. 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 4Dispatching 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 image 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 The segmentation of instructions of a data stream into groups is shown according to one embodiment.

[0019] Fig.13 Instruction slots on a tile that may be used to schedule instructions for execution in the tile are illustrated according to one embodiment.

[0020] Fig.14 Operations to schedule instructions are shown according to one embodiment.

[0021] Fig.15 A method to schedule instructions of an assembly language program for execution on a coarse-grained reconfigurable array is presented according to one embodiment.

[0022] Fig.16 A block diagram showing an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION

[0023] 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.

[0024] 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.

[0025] However, it is challenging to apply traditional compilation tools to program operations of new architectures, such as streaming 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 at 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 is capable of describing 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.

[0026] 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.

[0027] 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.

[0028] 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.

[0029] 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.

[0030] 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.

[0031] 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.

[0032] 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.

[0033] 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).

[0034] 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.

[0035] 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).

[0036] 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.

[0037] To schedule instructions for execution on tiles of a coarse-grained reconfigurable array (CGRA), a brute force approach can be used to explore all possible choices for instruction placement and scheduling, and then select the best execution schedule. However, due to the combinatorial explosion of choices, there are a large number of possible choices in the search space.

[0038] For example, a delay register of a tile may be used to implement a selected number of delays to synchronize output timing with input timing. Thus, the delay register introduces several possible choices, which may be multiplied with other choices to increase the possible choices. For example, a tile may have multiple tile memories that may be used to implement a memory variable; and the memory variable may be implemented in one of the tiles of a coarse-grained reconfigurable array (CGRA). Thus, there are many possible choices for the implementation of one memory variable; and as the number of memory variables increases, the possible implementations of the number of memory variables may increase significantly. The combination of which variables are implemented on which portion of which tile memory of which tiles and which instruction is scheduled on which clock cycle for execution on which tile can be minimized to a huge search space.

[0039] In one embodiment, the search space to be explored by the brute force method is reduced by performing a selection prior to the search. The selection reduces the search space and improves the efficiency of obtaining a valid schedule.

[0040] For example, the scheduler may be configured to determine the distribution of memory variables to tile memories according to some constraints before starting a brute force search. The distribution represents the allocation of memory variables of the program to tiles for implementation using the tile memories of the corresponding tiles. For example, this distribution may be performed with the goal of balancing the number of instructions / variables per tile. In addition, certain hardware details may be taken into account when determining the distribution (e.g., placing adjacent data in a data stream on tiles close to each other). Determining the distribution before scheduling instructions may reduce the number of combinations of choices to be explored by the brute force search.

[0041] For example, instructions may be placed in tiles in which memory variables used by the instructions are implemented. Thus, determining memory distribution prior to searching may reduce the choices for scheduling instructions; and instructions may be scheduled without having to explore possible choices associated with other tiles.

[0042] A dispatch schedule instruction based on one distribution of memory variables to tile memory may be executed independently of a dispatch schedule instruction based on another distribution. Thus, parallel searches may be performed based on different memory distributions. The resulting schedule with the best score (e.g., based on performance in terms of latency and / or power, etc.) may be used.

[0043] In one embodiment, the effective schedule is used to satisfy certain constraints. For example, instructions that share one or more tile memory variables should be placed on the same tile; instructions that each start a synchronous flow cannot be placed on the same tile; and / or multiple instructions of the same level cannot be placed on the same tile, etc. The scheduler can take these constraints into account when making choices, thereby reducing the choices that are exploited using a brute force approach.

[0044] For example, the scheduler may divide the instructions of the program into a target number of instruction groups. The target number may be equal to or greater than the number of synchronous data streams specified in the program. Each of the instruction groups is selected to be scheduled on the tile; and the instruction groups are selected to satisfy the constraints to be satisfied by the effective schedule.

[0045] Furthermore, partitioning of the instructions of the program into instruction groups may be performed to meet the addition requirements. For example, partitioning of the instructions of the program may be performed to balance the instruction groups so that each group has a similar number of instructions, and / or to balance the memory usage of the instruction groups so that each group has a similar total tile memory utilization, etc. Furthermore, within each instruction group, tile memory variables are allocated to tile memory regions (several) without exceeding the tile memory region size, without generating tile memory access conflicts for any instruction, etc.

[0046] After partitioning the instructions of a program into groups, a scheduler may schedule the instructions of each group and their corresponding tile memories on tiles of a coarse-grained reconfigurable array (CGRA) to generate a schedule.

[0047] In general, a program can be partitioned into different groups of instruction groups in different ways. Different groups of instruction groups can be executed in parallel to generate different schedules. The performance scores of the resulting schedules can be evaluated (e.g., based on latency and / or energy consumption, etc.) to select the best execution schedule as output.

[0048] In some embodiments, a tile of a coarse-grained reconfigurable array (CGRA) may have multiple instruction slots for pipeline execution. To schedule an instruction in a tile, a scheduler determines the slot of the tile to schedule the instruction for execution. The schedule for the instruction is selected to have an effective timing and slot configuration for the instruction, the preceding instructions that have been scheduled before the instruction, and the subsequent instructions that are scheduled after the instruction.

[0049] For example, the scheduler may be configured to recursively perform the operation of scheduling one instruction. For a current instruction selected for scheduling, the scheduler may search the parameters (e.g., slot and / or clock cycle) of the schedule of the current instruction to generate a valid schedule for the combination of the current instruction and the previous instruction that has been scheduled before the current instruction. If the scheduler finds a schedule that is valid in terms of timing and other constraints for the current instruction and the previous instruction that has been scheduled before the current instruction (if any), the scheduler continues to select the next instruction from the remaining instructions to be scheduled, and then processes the next instruction as the current instruction selected for scheduling until there are no remaining instructions to be scheduled.

[0050] However, if the scheduler determines that there is no valid schedule for the current instruction in view of the previous instructions that were scheduled before the current instruction, then the particular schedule of the previous instructions that were scheduled before the current instruction is invalid. The scheduler can then move back to the previous instruction that was scheduled before the current instruction and treat the previous instruction as the current instruction to be rescheduled. The process can continue until a valid schedule is found for the instruction group or it is determined that a valid schedule cannot be found for the instruction group.

[0051] Using the described techniques, the scheduler can generate at least one valid schedule for running a dataflow program in a coarse-grained reconfigurable array (CGRA) in a reasonable amount of time. The core functionality of the scheduler is extremely efficient in terms of time complexity because upon a scheduling failure, the scheduler immediately terminates the call, recovers the previously implemented schedule for a subset of the program's instructions, and continues searching for a new valid schedule for more instructions.

[0052] Figure 1 The structure of an assembly language program for execution in a coarse-grained reconfigurable array according to one embodiment is described.

[0053] exist Figure 1In 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 .

[0054] 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.

[0055] 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.

[0056] 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.

[0057] 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.

[0058] 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 .

[0059] Figure 2 Description According to one embodiment, an assembly language program is generated using a compiler.

[0060] 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.

[0061] 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.

[0062] 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.

[0063] For example, you can implement Figure 1 Assembly language program 101 for Figure 3 The coarse-grained reconfigurable array 103 is implemented.

[0064] 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.

[0065] 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.

[0066] 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.

[0067] 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.

[0068] 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.

[0069] 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.

[0070] 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.

[0071] Figure 4 Dispatching interface information of an assembly language program according to one embodiment is described.

[0072] For example, Figure 4 The dispatch interface information 111 can be used to Figure 1 In the assembly language program 101.

[0073] 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).

[0074] 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 .

[0075] 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.

[0076] Figure 5 Memory interface information of an assembly language program according to one embodiment is described.

[0077] For example, Figure 5 The memory interface information 113 can be used to Figure 1 In the assembly language program 101.

[0078] 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.

[0079] 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.

[0080] The memory properties (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).

[0081] Figure 6 The block memory information of an assembly language program according to one embodiment is described.

[0082] For example, Figure 6 The tile memory information 115 can be used to Figure 1 In the assembly language program 101.

[0083] 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.

[0084] 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.

[0085] 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.

[0086] Figure 7 A method of specifying operations in a coarse-grained reconfigurable array according to one embodiment is presented.

[0087] 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.

[0088] 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.

[0089] 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.

[0090] 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.

[0091] 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.

[0092] 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.

[0093] 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).

[0094] 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.

[0095] 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.

[0096] 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.

[0097] 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.

[0098] For example, compiler 107 may be configured to compile computer program 105 written in a high-level language to generate assembly language program 101 .

[0099] 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 .

[0100] 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.

[0101] Figure 8 An instruction execution schedule generated from an assembly language program according to one embodiment is described.

[0102] 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.

[0103] 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.

[0104] 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.

[0105] 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).

[0106] 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.

[0107] 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.

[0108] 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).

[0109] 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 the input of the subsequent computation in the correct cycle. Thus, data can flow in and among the tiles 141, 143, ..., 145 for synchronous operation.

[0110] 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 .

[0111] Fig. 9 A memory image for implementing an assembly language program in a coarse-grained reconfigurable array according to one embodiment is described.

[0112] exist Fig. 9 In the example, scheduler 221 identifies a memory image 225 for assembly language program 101 for coarse-grained reconfigurable array 103 having the structural features identified in hardware configuration file 239 .

[0113] For example, in a typical tile 141, memory variables 153, ..., 175 of assembly language program 101 are mapped in memory image 225 for implementation via tile memory 131, ..., 133 of tile 141. Other memory variables of assembly language program 101 are mapped to other tiles (e.g., 143, ..., 145).

[0114] When data stored in a variable (e.g., 153) is mapped to a tile (e.g., 141) for implementation 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 image 225 and the generation of the instruction execution schedule 223 may be performed together to identify the high-performance schedule 223.

[0115] 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 .

[0116] Fig.10 An execution configuration of a coarse-grained reconfigurable array for running an assembly language program according to one embodiment is described.

[0117] 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 scheduler 221 uses the hardware profile 239.

[0118] Configuration generator 229 may use hardware configuration file 249 to determine execution configuration 227 of assembly language program 101 having memory image 225 and instruction execution schedule 223 .

[0119] 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 .

[0120] For example, memory map 225 specifies which tile (e.g., 141) of coarse-grained reconfigurable array 103 is used to implement the memory represented by memory variable (e.g., 153). Configuration generator 229 may further determine which portion of tile memory (e.g., 131) in the tile (e.g., 141) is used for the memory represented by memory variable (e.g., 153) for executing configuration 227.

[0121] 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.

[0122] 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.

[0123] 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.

[0124] 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).

[0125] 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 .

[0126] 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.

[0127] 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.

[0128] 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).

[0129] 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.

[0130] 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.

[0131] 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 .

[0132] 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, ...).

[0133] 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 .

[0134] 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.

[0135] 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.

[0136] 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.

[0137] 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.

[0138] 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.

[0139] 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.

[0140] 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).

[0141] Fig.12 The segmentation of instructions of a data stream into groups is shown according to one embodiment.

[0142] For example, according to Fig.12 Will Figure 1 The instructions identified in the flow description 117 of the assembly language program 101 are divided into instruction groups.

[0143] For example, Figure 1The flow description 117 of the assembly language program 101 may list a plurality of data flows 301 , . . . , 303 .

[0144] For example, data flow 301 specifies a synchronized data flow through memory locations represented by memory variable 313. Data flow 301 further specifies instruction 311 that identifies an opcode for an operation to be performed on data flowing between memory locations represented by memory variable 313. Similarly, data flow 303 specifies memory variable 323 and instruction 321.

[0145] exist Fig.12 , instructions 311, ..., 321 and memory variables 313, ..., 323 of data streams 301, ..., 303 are divided 309 into a plurality of groups 305, ..., 307. The number of groups 305, ..., 307 is not less than the number of synchronous data streams 301, ..., 303.

[0146] For example, group 305 is configured to have instructions 233, ..., 243 and memory variables 153, ..., 175 from some of the data streams 301, ..., 303. Group 307 has instructions 331 and memory variables 333 from some of the data streams 301, ..., 303.

[0147] For example, since memory variables 153, ..., 175 are assigned to group 305, instructions 233, ..., 243 that operate on data at memory locations represented by memory variables 153, ..., 175 may also be assigned to group 305. However, instructions that operate on data at memory locations represented by memory variables that are not in group 305 are not assigned to group 305. Some instructions do not operate on memory variables that are mapped to tile memory for implementation and are therefore not restricted in their placement by the memory variable implementation.

[0148] Each of the groups 305 , . . . , 307 is to be implemented on a tile (eg, 141 , 143 , . . . , or 145 ) of the coarse-grained reconfigurable array 103 that is used to run a program having the data flows 301 , . . . , 303 .

[0149] Partition 309 is configured to enforce constraints 315. For example, instructions that share one or more tile memory variables should be placed on the same tile and therefore assigned to one or more groups to be implemented on the same tile. For example, instructions that each start a synchronized stream may not be placed on the same tile and therefore may not be placed in one or more groups to be implemented on the same tile. For example, multiple same-level instructions may not be placed on the same tile and therefore may not be placed in one or more groups to be implemented on the same tile.

[0150] Optionally, constraints 315 may include a requirement to balance instruction groups 305, ..., 307 so that each group has a similar number of instructions.

[0151] Optionally, constraints 315 may include a requirement to balance memory usage of instruction groups 305, ..., 307 so that each group has similar total tile memory utilization.

[0152] Within each instruction group (e.g., 305), tile memory variables (e.g., 153, ..., 175) are selected so that they can be allocated to (several) tile memory regions without exceeding the tile memory region size, without generating tile memory access conflicts for any instructions, etc.

[0153] Additionally, constraints 315 may include hardware considerations to improve performance (eg, placing adjacent data in a data stream in groups to be implemented on tiles close to each other).

[0154] As a result of partitioning 309, a memory map 225 is generated to map memory variables (e.g., 153, 175, ..., 333) to tiles (e.g., 141, 143, ..., 145) of coarse-grained reconfigurable array 103. Memory map 225 reduces the choices explored by the scheduler using a brute force approach when scheduling instructions.

[0155] Fig.12 The data stream 301, ..., 303 is illustrated as being partitioned 309 according to a constraint on a set of instruction groups 305, ..., 307. In general, the same constraint 315 may allow multiple sets of instruction groups of the data stream 301, ..., 303 to be partitioned in different ways.

[0156] Each of the different groups of instruction groups represents a different portion of the search space of possible choices for the scheduler 101. Therefore, the scheduler 221 can use each different group to search for an effective schedule for running the program instructions in the coarse-grained reconfigurable array 103. The parallel search can be performed based on the different groups of instruction programs respectively. After finding multiple effective schedules using the different groups of instruction groups, the best execution schedule can be selected to run the program 101.

[0157] Fig.13 Instruction slots on a tile that may be used to schedule instructions for execution in the tile are illustrated according to one embodiment.

[0158] exist Fig.13, a tile 141 of the coarse-grained reconfigurable array 103 may execute multiple instructions in parallel in different pipeline stages of the computational logic 137 of the tile 141. Instruction slots 351, 353, ..., 355 are configured to accept different instructions for pipeline execution. The tile 141 may execute a start 341 of executing an instruction in the slot 351 at a clock cycle 361 in the initial stage of the pipeline. In the next clock cycle 363, the execution 343 of the instruction in the slot 351 is executed in the next stage of the pipeline; and the initial stage may be used to execute the start 341 of the instruction in the next slot 353. Therefore, through pipeline operation, the tile may execute the instructions of the slots 351, 353, ..., 355 in parallel.

[0159] For example, at clock cycles 361, 363, ..., 365, the slice 141 performs launches 341 of instructions in slots 351, 353, ..., 355, respectively. At clock cycle 367, the slice 141 performs parallel execution 343 of the instructions in slots 351, 353, ..., 355, respectively, in different pipeline stages of the computational logic 137 of the slice 141. At clock cycle 369, completion 345 of execution is reached for the instruction in slot 351, and the slice 141 performs parallel execution 343 of the instructions in slots 353, ..., 355, respectively. After clock cycle 369, the instruction slot 351 may accept another instruction.

[0160] Thus, instructions assigned to tile 141 have multiple options for their execution. For example, the instruction may be placed in one of slots 351, 353, ..., 355 and scheduled for execution at an allowed clock cycle. For example, if an instruction is scheduled in slot 351 for execution at cycle 361, then the next instruction may be scheduled in slot 353 for execution at or after cycle 363, or the next instruction may be scheduled in slot 355 for execution at or after cycle 365, or the next instruction may be scheduled in slot 351 for execution after cycle 369.

[0161] For a selected option of scheduling an instruction in a slot (e.g., 351, 353, ..., or 355) for execution at a clock cycle (e.g., 361, 363, ..., 365, 367, ..., or 369), scheduler 221 may determine whether a timing requirement for connecting an output to an input is met for at least a combination of the current instruction and a previous instruction that has been scheduled before the current instruction. After finding a valid option for the current instruction, scheduler 221 may select the next instruction for scheduling, such as Fig.14 Like in.

[0162] Fig.14 Operations to schedule instructions are shown according to one embodiment.

[0163] exist Fig.14 , the scheduler 221 may select 371 the next instruction from the remaining instructions that have not yet been scheduled. For example, the scheduler 221 may select the next instruction according to the sequence of instructions in the data stream (e.g., 301 or 303). For example, the scheduler 221 may randomly select the next instruction.

[0164] If it is determined 373 that there is a next instruction to be scheduled, the scheduler 221 may continue to schedule the selected instruction. Otherwise, the scheduler 221 completes 387 the generation of the instruction execution schedule 223.

[0165] After selecting an instruction for scheduling, scheduler 221 may determine 375 an available location for placing the instruction.

[0166] For example, based on a memory image 225 that maps memory variables used by instructions (e.g., as described by Fig.12 The scheduler 221 may identify the tile in which the memory variable is implemented, based on the partition 309 in the memory, and then schedule the instruction for execution in the tile.

[0167] like Fig.13 As illustrated in , the scheduler 221 may further place the instruction in one of the instruction slots of the tile 141 .

[0168] If it is determined 377 that an available location (eg, slot) is found, the scheduler 221 may further determine 379 a valid schedule for the instruction.

[0169] For example, if an instruction is to be placed in an instruction slot, scheduler 221 may search for a clock cycle that satisfies the timing requirement for tile 141 to receive the instruction's input from a memory location that may receive output from the execution of other instructions.

[0170] If the scheduler 221 determines 381 that a valid schedule is found for the instruction, the scheduler 221 may further select 371 the next instruction for scheduling.

[0171] However, if the scheduler 221 determines 381 that a valid schedule is found for the current instruction being scheduled, then the scheduler 221 may determine 375 an alternative location for scheduling of the current instruction. If a suitable location cannot be found for the instruction, then the scheduler 221 may identify 383 the schedule of the previous instruction as invalid. Therefore, the previous instruction is selected for rescheduling. The scheduler 221 moves 385 to the previous instruction as the instruction for scheduling.

[0172] In determining 375 available locations and determining 379 a valid schedule, the scheduler 221 excludes options that have been previously identified 383 as invalid and / or previously evaluated.

[0173] The scheduler 221 may continue as follows Fig.14 The loop shown in is continued until the instructions of the instruction groups 305, ..., 307 have been scheduled or it is determined that the instruction groups 305, ..., 307 cannot be properly scheduled.

[0174] Fig.15 A method is presented for scheduling instructions of an assembly language program for execution on a coarse-grained reconfigurable array according to one embodiment.

[0175] For example, you can use Figure 12 to Figure 14 The technology in Figure 8 and Fig. 9 The scheduler 221 is configured Fig.15 method to provide Figure 8 Instruction execution schedule 223.

[0176] At block 271 , scheduler 221 receives assembly language program 101 that identifies a data flow 301 , . . . , 303 through memory locations represented by memory variables 313 , . . . , 323 and identifies instructions 311 , . . . , 321 configured to transform data in the data flow 301 , . . . , 303 .

[0177] At block 273, the scheduler 221 receives a hardware profile 239 that identifies characteristics of the coarse-grained reconfigurable array 103 having a plurality of tiles 141, 143, ..., 145 that may operate in parallel.

[0178] At box 275, the scheduler 221 generates a memory image 225 that identifies, for each corresponding memory variable (e.g., 153 or 175) in the assembly language program 101, one of the memory locations in the tile (e.g., 141) that contains the memory location represented by the corresponding memory variable (e.g., 153 or 175).

[0179] For example, scheduler 221 may be configured to generate memory image 225 by partitioning 309 memory variables 313, ..., 323 and instructions 311, ..., 321 of program 101 into a plurality of groups 305, ..., 307. Each of groups 305, ..., 307 is configured to be implemented on one of tiles 141, 143, ..., 145. Groups 305, ..., 307 as partitioned to be implemented on tiles 141, 143, ..., 145 satisfy constraints and / or requirements.

[0180] For example, instructions that share one or more tile memory variables are placed in one or more groups to be executed on the same tile.

[0181] For example, instructions that each start a synchronous stream are not placed in one or more groups to be executed on the same tile.

[0182] For example, multiple same-level instructions are not placed in one or more groups to be executed on the same tile, etc.

[0183] For example, partitioning 309 may be performed to balance the number of instructions implemented per tile, balance the number of memory variables implemented per tile, and / or balance the amount of memory usage implemented per tile, among other things.

[0184] At block 277 , the scheduler 221 assigns the instructions 311 , . . . , 321 to the tiles 141 , 143 , . . . , 145 for execution based on the memory image 225 .

[0185] For example, each respective instruction (eg, 233) among instructions 311, ..., 321 is assigned to a slice containing memory variables (eg, 153, 175) having data to be operated on by the respective instruction (eg, 233).

[0186] At block 279 , the scheduler 221 provides as output an instruction execution schedule 223 identifying the timing of executing the instructions 311 , . . . , 321 in the tile.

[0187] For example, the timing for executing instructions 311, ..., 321 may be determined by: selecting 371 a current instruction (e.g., 233) for scheduling; determining 375 an available location by identifying a slot (e.g., 353) in a first tile (e.g., 141) containing memory variables (e.g., 153, 175) used by the current instruction (e.g., 233); and determining 379 a valid schedule for the current instruction (233) by searching for a clock cycle (e.g., 231) for executing the current instruction (e.g., 233) in the slot (e.g., 353).

[0188] In response to determining 381 that a valid spoke RAM slot is found for executing the current instruction (eg, for execution at an active clock cycle 231 ), the scheduler 221 may select 371 a next instruction for scheduling.

[0189] In response to determining 381 that a valid spoke RAM slot for executing the current instruction (e.g., 233) in the slot (e.g., 353) is not found, the scheduler 221 is configured to search for an available slot in the first tile. In response to finding this available slot, the scheduler 221 can search for a clock cycle for executing the current instruction in the available slot.

[0190] However, in response to determining 375 that no available slot was found, the scheduler 221 is configured to: determine a prior instruction scheduled before the current instruction; identify 383 a first schedule previously determined for the prior instruction as invalid; and begin determining / searching a second valid schedule for the prior instruction.

[0191] Different memory images (e.g., 225) may be generated for the same assembly language program 101; and the operations in blocks 277 and 279 may be performed in parallel based on the different memory images to generate different instruction execution schedules (e.g., 223). Scheduler 221 may then evaluate the performance level (e.g., based on latency, energy consumption, etc.) of the instruction execution schedules (e.g., 223). The best execution schedule may be selected for running assembly language program 101 on coarse-grained reconfigurable array 103.

[0192] Fig.16 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.

[0193] Fig.16 The computer system of the present invention can be used to perform the operation of the scheduler 403 to generate the instruction execution schedule 223 to run the reference program on the coarse-grained reconfigurable array (CGRA) 103 by executing instructions configured to perform the operation corresponding to the scheduler 221. Figure 1 to Figure 1 7 The assembly language program 101 discussed above.

[0194] 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.

[0195] 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.

[0196] Fig.16The example computer system illustrated in 404 includes a processing device 402, a main memory 404, and a data storage system 418 that communicate with each other via a bus 430. For example, the processing device 402 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 430 may include, or be replaced by, multiple buses.

[0197] Fig.16 The processing device 402 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 402 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.

[0198] Fig.16 The computer system may further include a network interface device 408 for communicating via a computer network 420 .

[0199] The data storage system 418 may include a machine-readable medium 424 (also referred to as a computer-readable medium) having stored thereon one or more sets of instructions 426 or software embodying any one or more of the methodologies or functionality described herein. The instructions 426 may also reside, completely or at least partially, within the main memory 404 and / or the processing device 402 during execution by the computer system, the main memory 404 and the processing device 402 also constituting machine-readable storage media.

[0200] In one embodiment, the instructions 426 include instructions for implementing a method corresponding to the scheduler 403 (eg, referring to Figure 1 to Figure 1 7) of the assembly language program 101 described herein. Although the machine-readable medium 424 is shown as a single medium in the example embodiment, 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.

[0201] 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.

[0202] 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.

[0203] 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.

[0204] 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.

[0205] 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.

[0206] 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.

[0207] 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).

[0208] 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).

[0209] 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.

[0210] 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.

[0211] 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).

[0212] 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.

[0213] 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.

[0214] 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.

[0215] 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.

[0216] 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.).

[0217] 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.

[0218] 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.

[0219] 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 characteristics of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; generating a memory map that identifies, for each corresponding memory variable in the assembly language program, one of the tiles containing the memory location represented by the corresponding memory variable; assigning the instructions to the tiles for execution based on the memory image; An instruction execution schedule is provided, the instruction execution schedule identifying the timing of executing the instructions in the tile.

2. The method of claim 1 , wherein the generating of the memory image comprises: The memory variables and the instructions are partitioned into a plurality of groups, each of the groups being configured to be implemented on one of the tiles.

3. The method of claim 2, wherein the partitioning is performed to balance: The number of instructions implemented per tile; The number of memory variables implemented per tile; or The amount of memory used by each tile implementation.

4. The method of claim 2, wherein each respective one of the instructions is assigned to a slice containing a memory variable having data to be operated on by the respective instruction; and The timing of executing the instructions is determined by: Select the current instruction for scheduling; identifying a slot in a first slice containing a memory variable used by the current instruction; and A clock cycle for executing the current instruction in the slot is searched.

5. The method of claim 4, wherein the timing of executing the instructions is further determined by: A next instruction is selected for scheduling in response to determining that a valid spoke RAM slot is found for executing the current instruction.

6. The method of claim 4, wherein the timing of executing the instructions is further determined by: searching the first tile for an available slot in response to determining that no valid spoke RAM slot was found for executing the current instruction in the slot; and In response to finding the available slot, a clock cycle for executing the current instruction in the available slot is searched.

7. The method of claim 6, further comprising, in response to not finding an available slot: determining a previous instruction scheduled before the current instruction; identifying the first schedule previously determined for the prior instruction as invalid; and Determination of a second effective time schedule for the prior instruction begins.

8. 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 characteristics of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; generating a memory map that identifies, for each corresponding memory variable in the assembly language program, one of the tiles containing the memory location represented by the corresponding memory variable; assigning the instructions to the tiles for execution based on the memory image; An instruction execution schedule is provided, the instruction execution schedule identifying the timing of executing the instructions in the tile.

9. The computing device of claim 8, wherein to generate the memory image, the microprocessor is further configured to: partitioning the memory variables and the instructions into a plurality of groups, each of the groups being configured to be implemented on one of the tiles; Wherein each respective one of the instructions is assigned to a slice containing memory variables having data to be operated on by the respective instruction.

10. The computing device of claim 9, wherein the group is generated via: Balance the number of instructions implemented per tile; Balance the number of memory variables implemented per tile; or Balance the amount of memory used by each tile implementation; or Any combination thereof.

11. The computing device of claim 9, wherein the timing of executing the instructions is determined by: Select the current instruction for scheduling; identifying a slot in a first slice containing a memory variable used by the current instruction; and A clock cycle for executing the current instruction in the slot is searched.

12. The computing device of claim 11, wherein the timing of executing the instructions is further determined by: A next instruction is selected for scheduling in response to determining that a valid spoke RAM slot is found for executing the current instruction.

13. The computing device of claim 11, wherein the timing of executing the instructions is further determined by: searching the first tile for an available slot in response to determining that no valid spoke RAM slot was found for executing the current instruction in the slot; searching for a clock cycle for executing the current instruction in the available slot in response to finding the available slot; In response to no available slots being found: determining a previous instruction scheduled before the current instruction; identifying the first schedule previously determined for the prior instruction as invalid; and Determination of a second effective time schedule for the prior instruction begins.

14. 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 that identifies a data flow through a memory location represented by a memory variable and identifies an opcode configured to transform data in the data flow; receiving a hardware configuration file identifying characteristics of a coarse-grained reconfigurable array having a plurality of tiles capable of operating in parallel; generating a memory map that identifies, for each corresponding memory variable in the assembly language program, one of the tiles containing the memory location represented by the corresponding memory variable; assigning the opcode to the tile for execution based on the memory image; An opcode execution schedule is provided, the opcode execution schedule identifying the timing of executing the opcodes in the tiles.

15. The non-transitory computer storage medium of claim 14, wherein the generating of the memory image comprises: partitioning the memory variables and the instructions into a plurality of groups, each of the groups being configured to be implemented on one of the tiles; wherein each respective one of the instructions is assigned to a slice containing a memory variable having data to be operated on by the respective instruction; and Wherein the group is generated by: Balance the number of instructions implemented per tile; Balance the number of memory variables implemented per tile; or Balance the amount of memory used by each tile implementation; or Any combination thereof.