halide/Halide

Features

• High-Performance Image - Provides a C++ DSL for writing image processing algorithms that separate algorithm from schedule.
• Schedule Optimization via Learned Cost Models - Ships an automatic scheduler that uses a learned cost model and beam search to optimize pipeline performance.
• Pipeline - Offloads pipeline stages to GPU compute APIs such as CUDA, Metal, or DirectX 12.
• Heterogeneous Hardware Pipeline Compilation - Compiles pipelines to run on CPUs, GPUs, or accelerators without algorithm changes.
• Multi-Backend Compilers - Compiles the same pipeline to run on CPUs and GPUs without changing the algorithm.
• Image Pipeline Auto-Schedulers - Uses built-in heuristics to automatically choose performant schedules for image processing pipelines.
• Image Processing Pipeline Schedulers - Provides explicit scheduling directives to control loop mapping, parallelism, and memory layout for image processing pipelines.
• Pipeline Schedulers - Uses a learned cost model and beam search to automatically find high-performance schedules.
• Non-Planar Layout Handlers - Provides native handling of interleaved, planar, and custom memory layouts without data copying.
• Cross-Architecture Binary Compilation - Produces code for CPU or GPU architectures different from the host machine.
• Cross-Compilation Tooling - Generates machine code for CPU or GPU architectures different from the host build system.
• Pipeline Static Compilers - Generates standalone object files and headers from pipelines for deployment in larger applications.
• Cross-Architecture Pipeline Code Generation - Compiles the same pipeline to run on different CPU and GPU architectures without algorithm changes.
• Image Processing Stage Chains - Chains multiple image processing functions into sequential stages where each output feeds the next.
• Image Processing - Controls computation order, parallelism, vectorization, and memory layout of image processing pipeline stages.
• High-Performance Image Pipelines - Expresses image processing algorithms in a concise C++ DSL and compiles them to efficient machine code.
• Learned Cost Model Schedulers - Finds high-performance schedules using a learned cost model and beam search without manual tuning.
• Image Processing Pipelines - Declares image processing pipelines as directed acyclic graphs of functions, variables, and expressions.
• In-Memory Image Buffers - Stores and manipulates multi-dimensional pixel data with typed containers integrated with pipelines.
• Pipeline GPU Execution - Offloads pipeline stages to GPU compute APIs such as CUDA, Metal, or DirectX 12.
• Pipeline GPU Compilers - Compiles and runs pipeline stages on a GPU using the appropriate compute API.
• Ahead-Of-Time Compilation - Generates standalone object files or shared libraries from pipelines for use in external programs.
• Ahead-Of-Time Compilers - Compiles pipelines into standalone object files or static libraries for deployment.
• Image Processing DSLs - Provides an embedded C++ DSL for defining image processing pipelines as directed acyclic graphs.
• JIT Compilation Engines - Compiles pipelines into machine code at runtime for fast iteration and debugging.
• Image Processing Loop Transformations - Applies SIMD vectorization, multi-core parallelization, loop unrolling, and tiling to accelerate image processing pipelines.
• Cross-Architecture Code Generators - Compiles the same pipeline to run on CPUs and GPUs without algorithm changes.
• Multi-Stage Image Pipeline Compilation - Compiles multi-stage image processing pipelines as directed acyclic graphs into efficient machine code.
• Image Pipeline - Compiles image processing pipelines to optimized code for x86, ARM, CUDA, OpenCL, and Metal.
• Image Processing Performance Schedulers - Applies vectorization, parallelization, tiling, and unrolling strategies to optimize image processing pipeline execution.
• Scheduling Algorithms - Decouples computation from execution to enable independent optimization of memory, parallelism, and vectorization.
• Compile-Time Code Generation - Generates optimized machine code for CPUs and GPUs at compile time from a high-level DSL description.
• Image Processing - Controls how image processing pipeline stages are vectorized, parallelized, unrolled, or tiled for target optimization.
• Algorithm-Schedule Decoupling - Provides the core architectural principle of separating algorithm from schedule for independent optimization.
• Algorithm-Schedule Separation - Separates algorithm logic from execution scheduling for independent optimization of each.
• Runtime-Measured Schedule Optimizers - Refines schedules by measuring actual runtime on target hardware and iterating toward faster configurations.
• Pipeline Data Type Control - Controls data types and bit widths for variables, expressions, and buffers in pipelines.
• Pipeline Debugging and Profiling - Inspects generated code, traces intermediate values, and prints debug output during pipeline execution.
• Pipeline Tracing - Traces intermediate values and prints variable contents to inspect pipeline behavior step by step.
• Pipeline Value Tracing - Inserts trace statements and print calls into pipelines to inspect intermediate values during execution.
• Pipeline Print-Based Debugging - Inserts tracing and print statements into pipelines to inspect intermediate values during execution.
• Arbitrary Domain Evaluators - Evaluates pipelines over non-rectangular or user-defined sets of coordinates.
• Domain Scatter Operations - Applies computations repeatedly over multi-dimensional ranges, supporting reductions and scattering.
• Domain-Specific Reductions - Creates reduction operations that update function values over arbitrary or non-rectangular domains.
• Iterative Update Reductions - Expresses iterative or reduction operations that modify function values over multiple passes.
• Non-Rectangular Domain Reductions - Applies reduction operations over domains defined by arbitrary predicates, not just rectangles.
• Tuple Output Compilation - Compiles functions that return multiple distinct outputs in a single pass without intermediate storage.
• JIT Pipeline Compilation - Provides JIT compilation of pipelines for rapid prototyping and testing from C++.
• Multiple Return Values - Defines functions that produce tuples of several distinct outputs in a single pass.
• Multi-Domain Reductions - Defines iterative or reduction operations over arbitrary or non-rectangular domains.
• Associative Reduction Factoring - Splits associative reductions into independent partial results that can be computed in parallel and combined.
• Function Duplicators - Duplicates function definitions so the two copies can be scheduled independently.
• Higher-Order Function Wrapping - Creates wrapper functions that transform or filter outputs of existing functions without modifying them.
• Pipeline Generators - Wraps pipelines into reusable, parameterized generators for external compilation and invocation.
• Pipeline Parameterization - Declares runtime-configurable scalar and image inputs that can be changed without recompilation.
• C Geospatial Libraries - Language for high-performance image processing code.
• Low Level Geospatial Libraries - Optimizes high-performance image processing code.

Star-Verlauf