Memory Optimization for OpenCL on Intel FPGAs Exercise Manual

Transcription

1 Memory Optimization for OpenCL on Intel FPGAs Exercise Manual Software Requirements that cannot be adjusted: Intel FPGA SDK for OpenCL version 17.1 Software Requirements that can be adjusted: Operation System: CentOS 6.9 (Linux) Use the link below to download the design files for the exercise: *OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission of Khronos

2 In this exercise, you will practice using a few common techniques to improve local memory architecture in a component. We will look at how to bank explicitly on specified bits, how to guide the compiler to build a stall-free memory architecture, and how to merge memory. Step 1. Memory Banking and Coalescing Unzip the lab files using the command unzip lab.zip Change to the lab/ directory by typing cd lab Open the file in opencl_init.sh and change the paths to paths in your system to the Intel FPGA SDK for OpenCL installation directory Set up your environment for the lab by typing source opencl_init.sh Open bankbits.cl in a text editor This is a simple memory example, we have two local memory arrays, local_a and local_b. Based on the values of the input arguments, we will perform unrolled reads and writes. For the first loop, we would like local_a to be able to store 8 values at a time stall-free (because the loop is unrolled 8 times). For the second loop, we would 2

3 like local_a to be able to load 4 values at a time stall-free, and local_b to store 4 at a time. (The third loop is there to prevent optimizations from not using a result.) Since upperdim is constant for the duration of each of the loops, we should be able to bank the memory so that everything can be stall free. Many times, the compiler can figure out to do that. However, with complicated coding constructs, it cannot always figure out the correct structure. Compile bankbits into an object file by running the following command in the terminal: aoc -c -board=a10gx bankbits.cl When the compile has finished, open the HTML report by typing the following command (or use any web browser): firefox bankbits/reports/report.html Note the resource consumption of the Kernel System on the Summary page ALUTs FFs RAMs Go to Loop analysis What s the II of the component invocation? You see here that the II is ~1. The ~ in the II represents that the number is approximate because of stallable loads and stores. This is one case where the stallable loads and stores will cause you to have a much longer run time than you would have predicted using II alone. This is why it is important to examine all sections of the HTML report. Go to the System Viewer section of the HTML report. Here you can immediately see all of the loads and stores happening. There are 8 stores from the from the first loop, and 4 loads and stores from the second loop. 3

4 11. Hover over the local_b memory. You can see that the compiler ran this memory at 2x clock giving it 4 ports. It attempted to bank the memory on the lower bits but did not discover the optimal structure, and was not able to coalesce or replicate. Because there are 8 simultaneous access aggregating on 4 ports, these accesses are stallable and need to be arbitrated 4

5 12. Switch to the Kernel Memory Viewer section of the HTML report and click on Bank 0 of local_b in the Memory list. Here again you see the 8 accesses aggregating 8 ports with arbitration at every port. 5

6 Step 2. Change the kernel to optimize banking Open bankbits.cl in a text editor if it is not already open. Currently, the upper dimension of the arrays are indexed by upperdim+i. The intention of upperdim was to provide the upper bits of the address. However, the addition operation does not provide enough information to the compiler to know that upperdim will always be a multiple of 16. Mask the lower 4 bits of upperdim everywhere it is used. Also mask bits 31 to 9, leaving only bits 8 through 5 unmasked. Use the & operation with the number 0x000001F0. Save your modified kernel as bankbits_mask.cl Compile the kernel using aoc -c -board=a10gx bankbits_mask.cl. Open the HTML report by typing firefox bankbits_mask/reports/report.html Go to the System Viewer section of the report. You can quickly see by all of the red nodes that the compiler has not discovered the optimal banking structure Go back to the text editor and figure out the bits that would provide the optimal banking structure and use the attribute bankbits to specify that to the compiler. Hint: The only address bits where the 8 access differ is based on the loop variable i. The lowest dimention of the a array [2000] uses 11 bits. The LSB bit is bit 0. 3 bits are needed to provide 8 banks, which is the amount of banks we want. Save the modified kernel as bankbits_attribute.cl 6

7 Compile the kernel using the command below aoc -c -board=a10gx bankbits_attribute.cl Open the HTML report Go to the component viewer and hover over the local memory As you can see from this report, we have 8 banks but because we are not banking on the optimal bits, the local memory is still stallable. Go to an Area Report section of the HTML report. Note the resource consumption of the Kernel System. ALUTs FFs RAMs There is another recommendation that we have not followed yet. It is recommended to have the indices as powers of 2 to make it easier for the compiler to bank. Go back to the text editor and make the lower index of the local arrays a power of 2. Since it is already close to a power of 2, this will not add that many resources. Save your modified kernel as bankbits_powerof2.cl Compile the kernel into an object file. 7

8 15. Open the HTML report and go to the System Viewer section You can tell from the lack of red that the compiler figured out the optimal banking configuration and produced stall free nodes. Go to an Area Report section of the HTML report. Note the resource consumption of the Kernel System. ALUTs FFs RAMs Note the resource savings from an optimal banking structure. Stall-free nodes mean no arbitration is needed, and thus no resources are needed to build up arbiters and the control logic associated with stalls. Open the file bankbits_mask.cl again. You learned in class that the compiler prefers to bank on the lower dimension bits. In the bankbits_mask.cl file, turn the indices around every place they occur. Now, the variable i which we want to bank on is in the lower index. Save the file as bitbanks_turnaround.cl and compile it using the command shown below. aoc -c -board=a10gx bitbanks_turnaround.cl 8

9 Open the HTML report using the command firefox bitbanks_turnarond/reports/report.html Switch to the System Viewer section of the report. Using the lower indices allowed the tools to figure out a banking structure on its own, which is even more optimal than the one it finally chose with the upper bits. Try swapping indices first before all of the other things in real designs. Exercise Summary Practiced using bank attributes and coding styles for the compiler to generate the optimal memory architecture. Learned what technique is most effective for inferring banking. END OF EXERCISE 5 9

10 Intel Corporation. All rights reserved. Intel, the Intel logo, Altera, Arria, Cyclone, Enpirion, MAX, Nios, Quartus and Stratix words and logos are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries. Intel warrants performance of its FPGA and semiconductor products to current specifications in accordance with Intel's standard warranty, but reserves the right to make changes to any products and services at any time without notice. Intel assumes no responsibility or liability arising out of the application or use of any information, product, or service described herein except as expressly agreed to in writing by Intel. Intel customers are advised to obtain the latest version of device specifications before relying on any published information and before placing orders for products or services. *Other names and brands may be claimed as the property of others. 10