# uxlfoundation/onednn

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/uxlfoundation-onednn).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

4,009 stars · 1,148 forks · C++ · Apache-2.0

## Links

- GitHub: https://github.com/uxlfoundation/oneDNN
- Homepage: http://uxlfoundation.github.io/oneDNN/
- awesome-repositories: https://awesome-repositories.com/repository/uxlfoundation-onednn.md

## Topics

`aarch64` `amx` `avx512` `bfloat16` `cpp` `deep-learning` `deep-neural-networks` `library` `oneapi` `onednn` `openmp` `performance` `sycl` `tbb` `vnni` `x64` `x86-64` `xe-architecture`

## Description

oneDNN is a library for deep learning acceleration that provides optimized building blocks for neural network training and inference. It manages tensor computation across CPU and GPU hardware, enabling the execution of high-performance primitives for model training and neural network inference optimization.

The project distinguishes itself through hardware-specific kernel optimization and the use of just-in-time compilation to target specific processor instruction sets. It supports quantized neural network execution using both static and dynamic quantization to reduce memory usage and increase throughput.

The library covers a broad range of capabilities, including deep learning primitives such as convolutions, matrix multiplication, and recurrent neural network execution. It implements advanced performance optimizations including operation fusion, computation graph optimization, and memory format management. Integration is provided via a stable C ABI and C++ wrapper, with support for SYCL, OpenCL, and external linear algebra libraries.

The system includes observability tools for hardware performance profiling, primitive benchmarking, and verbose execution logging.

## Tags

### Part of an Awesome List

- [Deep Learning Acceleration](https://awesome-repositories.com/f/awesome-lists/devtools/gpu-acceleration/deep-learning-acceleration.md) — Provides optimized basic building blocks for neural networks to accelerate tensor operations across CPU and GPU hardware.
- [GPU Kernel Primitives](https://awesome-repositories.com/f/awesome-lists/devtools/gpu-acceleration/deep-learning-acceleration/gpu-kernel-primitives.md) — Implements highly tuned GPU kernels for fundamental deep learning operations like convolutions and matrix multiplications. ([source](https://cdn.jsdelivr.net/gh/uxlfoundation/onednn@main/README.md))

### Scientific & Mathematical Computing

- [High-Performance Scientific Computing](https://awesome-repositories.com/f/scientific-mathematical-computing/high-performance-execution-environments/scientific-computing-platforms/high-performance-scientific-computing.md) — Runs optimized high-performance scientific computing primitives such as convolutions and LSTM operations using pre-computed state. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_basic_concepts.html))
- [Tensor Computation Graphs](https://awesome-repositories.com/f/scientific-mathematical-computing/high-performance-execution-environments/scientific-computing-platforms/computational-frameworks/tensor-computation-graphs.md) — Represents sequences of mathematical operations as directed graphs of tensors to optimize execution flow and dependencies. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Matrix Multiplication Primitives](https://awesome-repositories.com/f/scientific-mathematical-computing/matrix-multiplication-primitives.md) — Executes matrix-matrix multiplication using floating-point, quantized, or sparse memory encodings across various data types. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Calculation Precision Configurations](https://awesome-repositories.com/f/scientific-mathematical-computing/calculation-precision-configurations.md) — Provides settings for managing numerical precision and significant digits during mathematical computations to balance speed and accuracy. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_accumulation_mode.html))
- [Element-wise Array Operations](https://awesome-repositories.com/f/scientific-mathematical-computing/element-wise-array-operations.md) — Applies high-performance arithmetic, comparison, or selection operators between two tensors element-wise. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_binary.html))
- [Floating-Point Precision Conversions](https://awesome-repositories.com/f/scientific-mathematical-computing/floating-point-precision-conversions.md) — Converts floating-point data to narrower types during computation to increase speed while maintaining original storage precision. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_fpmath_mode.html))
- [Tensor Manipulations](https://awesome-repositories.com/f/scientific-mathematical-computing/tensor-manipulations.md) — Performs complex tensor transformations including binary operations, concatenation, reduction, and reordering of data shapes. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))

### Artificial Intelligence & ML

- [Accelerated Normalization Layers](https://awesome-repositories.com/f/artificial-intelligence-ml/accelerated-normalization-layers.md) — Provides high-performance implementations of batch, group, layer, and local response normalization to accelerate training. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Activation Functions](https://awesome-repositories.com/f/artificial-intelligence-ml/activation-functions.md) — Implements non-linear activation functions such as PReLU and Softmax to be applied element-wise to tensors. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Backward Propagation Primitives](https://awesome-repositories.com/f/artificial-intelligence-ml/backward-propagation-primitives.md) — Calculates operation gradients using source or destination tensors to update weights during neural network training. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_eltwise.html))
- [Batch Normalization](https://awesome-repositories.com/f/artificial-intelligence-ml/batch-normalization.md) — Calculates forward and backward normalization on multi-dimensional tensors using mean and variance to stabilize training. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_batch_normalization.html))
- [Convolutional Operations](https://awesome-repositories.com/f/artificial-intelligence-ml/convolutional-operations.md) — Executes high-performance forward, backward, and weight update passes for multi-dimensional convolutions, including grouped and dilated variants. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_convolution.html))
- [Deep Network Training](https://awesome-repositories.com/f/artificial-intelligence-ml/deep-learning-training-toolsets/deep-network-training.md) — Implements high-performance primitives for calculating gradients and performing backward propagation during deep network training.
- [Just-In-Time Kernel Compilers](https://awesome-repositories.com/f/artificial-intelligence-ml/just-in-time-kernel-compilers.md) — Uses just-in-time compilation to target specific processor instruction sets and maximize hardware-specific execution speed.
- [Graph Fusions](https://awesome-repositories.com/f/artificial-intelligence-ml/kernel-fusion-compilers/graph-fusions.md) — Groups individual primitives into high-level graphs to automatically apply backend-aware operation fusions for better performance. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_basic_concepts.html))
- [Kernel Optimizers](https://awesome-repositories.com/f/artificial-intelligence-ml/kernel-optimizers.md) — Optimizes the dispatch of JIT-generated kernels by preferring specific CPU instruction set features for maximum performance. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_cpu_isa_hints.html))
- [Convolution Layers](https://awesome-repositories.com/f/artificial-intelligence-ml/machine-learning/frameworks/model-construction/neural-network-layers/convolution-layers.md) — Implements convolutional and transposed convolutional layers for processing spatial data in forward and training modes. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Tensor Memory Management](https://awesome-repositories.com/f/artificial-intelligence-ml/machine-learning/infrastructure/model-optimization-and-inference/hardware-and-acceleration/tensor-computing-libraries/tensor-memory-management.md) — Manages tensor memory layouts, data shapes, and device allocations across different hardware engines.
- [Hardware-Aware Graph Partitioning](https://awesome-repositories.com/f/artificial-intelligence-ml/model-graph-optimizers/hardware-aware-graph-partitioning.md) — Analyzes operations and decomposes them into optimized sub-graphs and partitions to maximize efficiency on specific hardware. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_graph_basic_concepts.html))
- [Low Precision Inference](https://awesome-repositories.com/f/artificial-intelligence-ml/model-optimization/compression-techniques/model-pruning/model-compression-suites/half-precision-compression/mixed-precision-quantization/low-precision-inference.md) — Executes deep learning operations using reduced-precision numerical types to increase throughput and reduce memory usage. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_data_types.html))
- [Static Quantization](https://awesome-repositories.com/f/artificial-intelligence-ml/model-quantization/8-bit-inference-quantizers/static-quantization.md) — Maps quantized integers to floating-point values during primitive execution using pre-defined scales and zero-points. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_quantization.html))
- [Dynamic Quantization](https://awesome-repositories.com/f/artificial-intelligence-ml/model-quantization/8-bit-inference-quantizers/static-quantization/dynamic-quantization.md) — Computes scaling factors on the fly for groups of elements during inference to reduce precision and increase throughput. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_quantization.html))
- [Primitive Accelerators](https://awesome-repositories.com/f/artificial-intelligence-ml/neural-network-layers/primitive-accelerators.md) — Provides tuned acceleration routines for basic neural network operations across CPU and GPU hardware. ([source](http://uxlfoundation.github.io/oneDNN/))
- [Inference Optimizations](https://awesome-repositories.com/f/artificial-intelligence-ml/neural-networks/inference-optimizations.md) — Increases inference throughput and reduces memory bandwidth through operation fusion and low-precision numerical types.
- [Quantized Neural Network Execution](https://awesome-repositories.com/f/artificial-intelligence-ml/quantized-neural-network-execution.md) — Runs integer-based deep learning operations using scaling factors and zero points to reduce memory usage and increase speed.
- [Recurrent Neural Networks](https://awesome-repositories.com/f/artificial-intelligence-ml/recurrent-neural-networks.md) — Provides high-performance primitives for processing sequential data using RNN, LSTM, GRU, and AUGRU architectures. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Sparse Computing Kernels](https://awesome-repositories.com/f/artificial-intelligence-ml/sparse-computing-kernels.md) — Utilizes sparse memory formats and specialized kernels to reduce memory footprint and skip zero-value computations. ([source](http://uxlfoundation.github.io/oneDNN/advanced_topics.html))
- [Memory Layout Optimizations](https://awesome-repositories.com/f/artificial-intelligence-ml/training-memory-management/memory-layout-optimizations.md) — Configures model memory formats and data layouts to maximize throughput on tensor cores and other accelerators. ([source](http://uxlfoundation.github.io/oneDNN/advanced_topics.html))
- [Depthwise Separable Convolutions](https://awesome-repositories.com/f/artificial-intelligence-ml/convolutional-neural-networks/pointwise-convolutions/depthwise-separable-convolutions.md) — Implements optimized depthwise separable convolutions by fusing depthwise and pointwise operations to accelerate separable convolution stacks. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_post_ops.html))
- [Dequantizing Runtimes](https://awesome-repositories.com/f/artificial-intelligence-ml/dequantizing-runtimes.md) — Implements on-the-fly conversion of integer weights back to floating-point format during computation. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_quantization.html))
- [Dropout Regularization](https://awesome-repositories.com/f/artificial-intelligence-ml/dropout-regularization.md) — Integrates dropout regularization directly into the primitive output buffer to prevent overfitting during neural network training. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes.html))
- [Mixture-of-Experts Inference Optimizers](https://awesome-repositories.com/f/artificial-intelligence-ml/mixture-of-experts-inference-optimizers.md) — Uses grouped memory formats and grouped GEMM to optimize variable-size batching for Mixture-of-Experts model inference. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_experimental.html))
- [Primitive State Caching](https://awesome-repositories.com/f/artificial-intelligence-ml/neural-network-layers/primitive-accelerators/primitive-state-caching.md) — Stores and reuses previously created execution primitives to avoid the overhead of repeated initialization. ([source](http://uxlfoundation.github.io/oneDNN/advanced_topics.html))
- [Operator Fusions](https://awesome-repositories.com/f/artificial-intelligence-ml/optimization-algorithms/high-performance-optimizer-implementations/execution-pattern-optimizations/operator-fusions.md) — Reduces inference overhead by fusing neural network primitives with subsequent post-operations into single kernels. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes.html))
- [Optimized Partition Execution](https://awesome-repositories.com/f/artificial-intelligence-ml/optimized-partition-execution.md) — oneDNN runs compiled binary code using bound data buffers and streams to process multi-dimensional tensors on a target engine. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_graph_basic_concepts.html))
- [Quantization Granularity Settings](https://awesome-repositories.com/f/artificial-intelligence-ml/precision-quantization/mixed-granularity-quantization/quantization-granularity-settings.md) — Provides configuration options to define the scope of quantization, ranging from global tensors to block-wise masks. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_quantization.html))
- [Primitive Execution Configurations](https://awesome-repositories.com/f/artificial-intelligence-ml/primitive-execution-configurations.md) — Adjusts operational behavior through math modes and accumulation precision to balance performance and accuracy. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes.html))
- [Parameter Definitions](https://awesome-repositories.com/f/artificial-intelligence-ml/quantized-inference-runtimes/weight-quantization/quantized-parameter-mapping/parameter-definitions.md) — Defines specific quantization settings and parameters required for performing integer-based inference. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes.html))
- [Transposed Convolutions](https://awesome-repositories.com/f/artificial-intelligence-ml/transposed-convolutions.md) — Implements transposed convolutions to expand input data and reconstruct spatial resolution during upsampling. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_convolution.html))

### Data & Databases

- [Runtime Hardware Optimizers](https://awesome-repositories.com/f/data-databases/hardware-acceleration/runtime-hardware-optimizers.md) — Automatically detects host processor capabilities at runtime to select the most efficient instruction sets for acceleration. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_build_options.html))
- [Tensor Caches](https://awesome-repositories.com/f/data-databases/in-memory-caches/tensor-caches.md) — Stores reordered weights and folded scales in memory to eliminate redundant computations across hardware engines. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_constant_tensor_cache.html))

### Hardware & IoT

- [Tensor Layout Optimizations](https://awesome-repositories.com/f/hardware-iot/tensor-layout-optimizations.md) — Restructures multi-dimensional tensor layouts to align with physical memory and maximize hardware processing unit throughput. ([source](https://uxlfoundation.github.io/oneDNN/group_dnnl_api.html))

### Operating Systems & Systems Programming

- [CPU Instruction Optimizations](https://awesome-repositories.com/f/operating-systems-systems-programming/cpu-instruction-optimizations.md) — Targets specific processor instruction sets like AVX-512 and AMX to maximize execution speed through low-level optimizations. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_cpu_dispatcher_control.html))
- [CPU Primitive Execution](https://awesome-repositories.com/f/operating-systems-systems-programming/cpu-primitive-execution.md) — Runs deep learning operations on various processor architectures using just-in-time code generation for the detected instruction set. ([source](https://cdn.jsdelivr.net/gh/uxlfoundation/onednn@main/README.md))
- [Device-Specific Memory Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/explicit-memory-allocators/device-specific-memory-allocators.md) — Provides specialized allocators for managing tensors in discrete device memory spaces and facilitating host-to-device transfers. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_basic_concepts.html))
- [GPU Memory Optimizations](https://awesome-repositories.com/f/operating-systems-systems-programming/gpu-memory-optimizations.md) — Optimizes memory throughput by managing format propagation and reordering data between CPU and GPU engines. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))
- [Task Dependencies](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-interfacing-drivers/hardware-acceleration/gpu-acceleration/task-dependencies.md) — Synchronizes execution between primitives using events or in-order streams to prevent data races in hardware-accelerated tasks. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_dpcpp_interoperability.html))
- [Hardware Runtime Configurations](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-runtime-configurations.md) — Defines the threading model and offload runtime to match the target hardware environment. ([source](https://uxlfoundation.github.io/oneDNN/dev_guide_build_options.html))
- [Inference Buffer Management](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/gpu-memory-allocators/inference-buffer-management.md) — Manages the allocation and sizing of short-term memory buffers for intermediate deep learning calculations. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_scratchpad.html))
- [Unified Memory Managers](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/gpu-memory-allocators/unified-memory-managers.md) — Implements unified memory management for high-performance data transfer between host and device memory spaces. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_dpcpp_interoperability.html))
- [Micro-Kernel Compositions](https://awesome-repositories.com/f/operating-systems-systems-programming/memory-block-operations/micro-kernel-compositions.md) — Enables the composition of sequential micro-kernels to implement specialized operations with manual control over threading and blocking. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_basic_concepts.html))
- [Microkernel Execution Control](https://awesome-repositories.com/f/operating-systems-systems-programming/microkernel-execution-control.md) — Provides manual control over threading and blocking logic on CPUs via microkernel interfaces to maximize hardware customization. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))

### Programming Languages & Runtimes

- [ISA-Level Binary Generation](https://awesome-repositories.com/f/programming-languages-runtimes/binary-compilation/isa-level-binary-generation.md) — Lowers computation logic to hardware ISA level and generates specialized binary code based on tensor metadata. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_graph_basic_concepts.html))
- [Runtime GPU Kernel Compilation Libraries](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-infrastructure/jit-kernel-compilers/runtime-gpu-kernel-compilation-libraries.md) — Compiles kernels online using just-in-time compilation to enable dynamic specialization for the detected hardware. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_experimental.html))
- [Custom Operator APIs](https://awesome-repositories.com/f/programming-languages-runtimes/ahead-of-time-compilation/static-memory-planning/model-specific-memory-planning/operator-implementation-customizations/custom-operator-apis.md) — Provides low-level APIs to compose sequential block-level operations and tailor threading logic for specific applications. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_experimental.html))
- [Heterogeneous Hardware Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/heterogeneous-hardware-runtimes.md) — Shares data and execution contexts with external runtimes to coordinate workloads across heterogeneous CPU and GPU cores. ([source](https://uxlfoundation.github.io/oneDNN/group_dnnl_api.html))
- [Normalization and Activation Fusions](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/graph-symbolic-execution-engines/operation-kernels/kernel-fusion-operations/elementwise-and-tensor-math-fusions/normalization-and-activation-fusions.md) — Fuses normalization, binary addition, and activation into a single operation to increase training speed and reduce memory overhead. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_batch_normalization.html))
- [Sequential Operation Fusion](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/graph-symbolic-execution-engines/operation-kernels/sequential-operation-fusion.md) — Combines primitives with element-wise operations into single kernels to eliminate intermediate memory writes and reduce overhead. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_post_ops.html))

### Software Engineering & Architecture

- [Kernel Implementation Selection](https://awesome-repositories.com/f/software-engineering-architecture/development-methodologies/performance-optimization-principles/algorithmic-performance-optimizations/kernel-implementation-selection.md) — Selects between direct, Winograd, or implicit GEMM implementations to balance performance, memory, and numerical accuracy. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_convolution.html))
- [Numerical Result Determinism](https://awesome-repositories.com/f/software-engineering-architecture/deterministic-execution-environments/numerical-result-determinism.md) — Guarantees that multiple executions of the same operation return bit-wise identical results for debugging and validation. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_attributes_deterministic.html))

### Development Tools & Productivity

- [Binary Footprint Reduction](https://awesome-repositories.com/f/development-tools-productivity/build-optimization/binary-footprint-reduction.md) — Implements build-time optimizations to limit available primitives and decrease the overall size of the compiled binary. ([source](https://uxlfoundation.github.io/oneDNN/dev_guide_build_options.html))

### DevOps & Infrastructure

- [Thread Scaling](https://awesome-repositories.com/f/devops-infrastructure/process-scaling/thread-scaling.md) — Distributes computational workloads across multiple CPU cores using threadpool-based threading models to maximize utilization. ([source](http://uxlfoundation.github.io/oneDNN/advanced_topics.html))

### System Administration & Monitoring

- [Operation Benchmarkers](https://awesome-repositories.com/f/system-administration-monitoring/monitoring-and-observability/observability-platforms/metric-performance-monitors/performance-benchmarkers/operation-benchmarkers.md) — Measures the execution time of specific deep learning primitives to verify optimization gains. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_benchdnn.html))

### Testing & Quality Assurance

- [Performance Analysis](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-analysis.md) — Uses performance profilers and verbose logging to analyze internal operations and identify algorithmic bottlenecks. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_build_options.html))
- [Performance Profiling](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-profiling.md) — Measures execution time and efficiency of primitives to identify and resolve performance bottlenecks. ([source](http://uxlfoundation.github.io/oneDNN/dev_guide_examples.html))