FPGA Development

  1. High-Level Synthesis
    1. Introduction to HLS
      1. HLS Concepts
        1. From Software to Hardware
          1. Algorithmic Description
            1. Automatic RTL Generation
            2. Differences Between HLS and RTL Design
              1. Abstraction Level
                1. Design Productivity
                  1. Optimization Opportunities
                  2. HLS Languages
                    1. C/C++ for Hardware
                      1. SystemC
                        1. OpenCL
                        2. HLS Tool Overview
                          1. Xilinx Vitis HLS
                            1. Intel HLS Compiler
                              1. Catapult HLS
                            2. The HLS Design Flow
                              1. C-Simulation
                                1. Algorithm Verification
                                  1. Testbench Development
                                    1. Functional Correctness
                                    2. Synthesis to RTL
                                      1. Scheduling
                                        1. Resource Allocation
                                          1. Binding
                                            1. RTL Generation
                                            2. Co-Simulation
                                              1. Verifying Generated RTL
                                                1. Interface Protocol Checking
                                                  1. Performance Validation
                                                  2. RTL Export
                                                    1. IP Core Generation
                                                      1. Integration with RTL Designs
                                                      2. Implementation Flow
                                                        1. Synthesis and Implementation
                                                          1. Performance Analysis
                                                        2. HLS Optimization Techniques
                                                          1. Pragmas and Directives
                                                            1. Synthesis Directives
                                                              1. Interface Directives
                                                                1. Optimization Directives
                                                                2. Loop Optimization
                                                                  1. Loop Pipelining
                                                                    1. Initiation Interval
                                                                      1. Pipeline Hazards
                                                                      2. Loop Unrolling
                                                                        1. Partial Unrolling
                                                                          1. Complete Unrolling
                                                                            1. Factor Selection
                                                                            2. Loop Merging
                                                                              1. Loop Flattening
                                                                              2. Array Optimization
                                                                                1. Array Partitioning
                                                                                  1. Block Partitioning
                                                                                    1. Cyclic Partitioning
                                                                                      1. Complete Partitioning
                                                                                      2. Array Reshaping
                                                                                        1. Memory Interface Optimization
                                                                                        2. Function Optimization
                                                                                          1. Function Pipelining
                                                                                            1. Function Inlining
                                                                                              1. Dataflow Optimization
                                                                                              2. Interface Optimization
                                                                                                1. AXI Interface Configuration
                                                                                                  1. Streaming Interfaces
                                                                                                    1. Memory Interface Optimization
                                                                                                    2. Resource Optimization
                                                                                                      1. Resource Sharing
                                                                                                        1. Resource Allocation
                                                                                                          1. DSP Utilization
                                                                                                            1. BRAM Utilization
                                                                                                            2. Performance Trade-offs
                                                                                                              1. Latency vs. Throughput
                                                                                                                1. Area vs. Performance
                                                                                                                  1. Power vs. Performance
                                                                                                                2. Advanced HLS Concepts
                                                                                                                  1. Dataflow Design
                                                                                                                    1. Task-Level Parallelism
                                                                                                                      1. Channel Communication
                                                                                                                        1. Producer-Consumer Patterns
                                                                                                                        2. Streaming Applications
                                                                                                                          1. Stream Processing
                                                                                                                            1. Sliding Window Operations
                                                                                                                              1. Filter Implementations
                                                                                                                              2. Fixed-Point Design
                                                                                                                                1. Fixed-Point Data Types
                                                                                                                                  1. Precision Analysis
                                                                                                                                    1. Quantization Effects
                                                                                                                                    2. Custom Data Types
                                                                                                                                      1. Arbitrary Precision Integers
                                                                                                                                        1. Custom Structures
                                                                                                                                          1. Bit-Level Operations
                                                                                                                                          2. Memory Hierarchy
                                                                                                                                            1. On-Chip Memory Usage
                                                                                                                                              1. External Memory Access
                                                                                                                                                1. Cache Implementation
                                                                                                                                                2. Error Handling
                                                                                                                                                  1. Synthesis Errors
                                                                                                                                                    1. Timing Closure Issues
                                                                                                                                                      1. Resource Constraints

                                                                                                                                                  Previous

                                                                                                                                                  9. On-Chip Debugging and Practical Implementation

                                                                                                                                                  Go to top

                                                                                                                                                  Back to Start

                                                                                                                                                  1. Introduction to FPGAs and Digital Logic